* Volume rendering
[blender-staging.git] / source / blender / src / buttons_shading.c
index e42a0570fe71438e3eca83665af866476c455e20..bdb2fe5a3f37ffcababb5d095aae98e22825920c 100644 (file)
@@ -52,6 +52,7 @@
 #include "DNA_object_types.h"
 #include "DNA_node_types.h"
 #include "DNA_packedFile_types.h"
+#include "DNA_particle_types.h"
 #include "DNA_radio_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
@@ -62,6 +63,7 @@
 #include "DNA_world_types.h"
 
 #include "BKE_colortools.h"
+#include "BKE_depsgraph.h"
 #include "BKE_displist.h"
 #include "BKE_effect.h"
 #include "BKE_global.h"
@@ -69,6 +71,7 @@
 #include "BKE_main.h"
 #include "BKE_node.h"
 #include "BKE_material.h"
+#include "BKE_particle.h"
 #include "BKE_utildefines.h"
 #include "BKE_texture.h"
 
 
 #include "RE_pipeline.h"
 
+#include "GPU_material.h"
+
 /* -----includes for this file specific----- */
 
 #include "butspace.h" // own module
@@ -139,6 +144,11 @@ static char *mapto_blendtype_pup(void)
        str += sprintf(str, formatstr, "Darken", MTEX_DARK);
        str += sprintf(str, formatstr, "Lighten", MTEX_LIGHT);
 
+       str += sprintf(str, formatstr, "Hue", MTEX_BLEND_HUE);
+       str += sprintf(str, formatstr, "Saturation", MTEX_BLEND_SAT);
+       str += sprintf(str, formatstr, "Value", MTEX_BLEND_VAL);
+       str += sprintf(str, formatstr, "Color", MTEX_BLEND_COLOR);
+       
        return string;
 }
 
@@ -201,6 +211,7 @@ static void load_image_cb(char *str, void *ima_pp_v, void *iuser_v) /* called fr
                        if(GS(tex->id.name)==ID_TE) {
                                BIF_preview_changed(ID_TE);
                                allqueue(REDRAWBUTSSHADING, 0);
+                               allqueue(REDRAWVIEW3D, 0);
                                allqueue(REDRAWOOPS, 0);
                        }
                }
@@ -230,7 +241,7 @@ static void save_env(char *name)
        char str[FILE_MAX];
        
        strcpy(str, name);
-       BLI_convertstringcode(str, G.sce, G.scene->r.cfra);
+       BLI_convertstringcode(str, G.sce);
        tex= G.buts->lockpoin;
        
        if(tex && GS(tex->id.name)==ID_TE) {
@@ -740,8 +751,7 @@ static char *layer_menu(RenderResult *rr, short *curlay)
                a+= sprintf(str+a, "|%s %%x%d", rl->name, nr);
        }
        
-       if(*curlay >= nr)
-               *curlay= 0;
+       /* no curlay clip here, on render (redraws) the amount of layers can be 1 fir single-layer render */
        
        return str;
 }
@@ -1168,33 +1178,35 @@ void uiblock_image_panel(uiBlock *block, Image **ima_pp, ImageUser *iuser,
                 
                 /* fields */
                 uiBlockBeginAlign(block);
-                but= uiDefButBitS(block, TOG, IMA_FIELDS, imagechanged, "Fields",      10, 90, 100, 20, &ima->flag, 0, 0, 0, 0, "Click to enable use of fields in Image");
+                but= uiDefButBitS(block, TOG, IMA_FIELDS, imagechanged, "Fields",      10, 70, 65, 20, &ima->flag, 0, 0, 0, 0, "Click to enable use of fields in Image");
                 uiButSetFunc(but, image_field_test, ima, iuser);
-                uiDefButBitS(block, TOG, IMA_STD_FIELD, B_NOP, "Odd",                  10, 70, 100, 20, &ima->flag, 0, 0, 0, 0, "Standard Field Toggle");
-                uiBlockEndAlign(block);
+                uiDefButBitS(block, TOG, IMA_STD_FIELD, B_NOP, "Odd",                  75, 70, 45, 20, &ima->flag, 0, 0, 0, 0, "Standard Field Toggle");
                 
-                uiDefButBitS(block, TOG, IMA_ANTIALI, B_NOP, "Anti",                   10, 35, 100, 20, &ima->flag, 0, 0, 0, 0, "Toggles Image anti-aliasing, only works with solid colors");
+                uiBlockSetFunc(block, image_reload_cb, ima, iuser);
+                uiDefButBitS(block, TOG, IMA_ANTIALI, B_NOP, "Anti",                   10, 50, 45, 20, &ima->flag, 0, 0, 0, 0, "Toggles Image anti-aliasing, only works with solid colors");
+                uiDefButBitS(block, TOG, IMA_DO_PREMUL, imagechanged, "Premul",                55, 50, 65, 20, &ima->flag, 0, 0, 0, 0, "Toggles premultiplying alpha");
+                uiBlockEndAlign(block);
                 
                 if( ELEM(ima->source, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
                         sprintf(str, "(%d) Frames:", iuser->framenr);
                         
                         uiBlockBeginAlign(block);
                         uiBlockSetFunc(block, image_user_change, iuser, NULL);
-                        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");
+                        uiDefButBitS(block, TOG, IMA_ANIM_ALWAYS, B_NOP, "Auto Refresh",       120, 70, 190, 20, &iuser->flag, 0, 0, 0, 0, "Always refresh Image on frame changes");
                         
                         if(ima->anim) {
-                                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");
-                                but= uiDefBut(block, BUT, redraw, "<",         290, 70, 20, 20, 0, 0, 0, 0, 0, "Copies number of frames in movie file to Frames: button");
+                                uiDefButI(block, NUM, imagechanged, str,               120, 50,170, 20, &iuser->frames, 0.0, MAXFRAMEF, 0, 0, "Sets the number of images of a movie to use");
+                                but= uiDefBut(block, BUT, redraw, "<",         290, 50, 20, 20, 0, 0, 0, 0, 0, "Copies number of frames in movie file to Frames: button");
                                 uiButSetFunc(but, set_frames_cb, ima, iuser);
                         }
                         else 
-                                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");
+                                uiDefButI(block, NUM, imagechanged, str,               120, 50,190, 20, &iuser->frames, 0.0, MAXFRAMEF, 0, 0, "Sets the number of images of a movie to use");
                         
-                        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");
-                        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)");
+                        uiDefButI(block, NUM, imagechanged, "Offs:",   120,30,100,20, &iuser->offset, -MAXFRAMEF, MAXFRAMEF, 0, 0, "Offsets the number of the frame to use in the animation");
+                        uiDefButS(block, NUM, imagechanged, "Fie/Ima:",        220,30,90,20, &iuser->fie_ima, 1.0, 200.0, 0, 0, "The number of fields per rendered frame (2 fields is 1 image)");
                         
-                        uiDefButI(block, NUM, imagechanged, "StartFr:",        120,30,100,20, &iuser->sfra, 1.0, MAXFRAMEF, 0, 0, "Sets the global starting frame of the movie");
-                        uiDefButS(block, TOG, imagechanged, "Cyclic",  220,30,90,20, &iuser->cycl, 0.0, 1.0, 0, 0, "Cycle the images in the movie");
+                        uiDefButI(block, NUM, imagechanged, "StartFr:",        120,10,100,20, &iuser->sfra, 1.0, MAXFRAMEF, 0, 0, "Sets the global starting frame of the movie");
+                        uiDefButS(block, TOG, imagechanged, "Cyclic",  220,10,90,20, &iuser->cycl, 0.0, 1.0, 0, 0, "Cycle the images in the movie");
                         
                         uiBlockSetFunc(block, NULL, iuser, NULL);
                 }
@@ -1202,9 +1214,9 @@ void uiblock_image_panel(uiBlock *block, Image **ima_pp, ImageUser *iuser,
                         
                         uiBlockBeginAlign(block);
                         uiBlockSetFunc(block, image_generated_change_cb, ima, iuser);
-                        uiDefButS(block, NUM, imagechanged, "SizeX:",  120,90,100,20, &ima->gen_x, 1.0, 5000.0, 0, 0, "Image size x");
-                        uiDefButS(block, NUM, imagechanged, "SizeY:",  220,90,90,20, &ima->gen_y, 1.0, 5000.0, 0, 0, "Image size y");
-                        uiDefButS(block, TOG, imagechanged, "UV Test grid",120,70,190,20, &ima->gen_type, 0.0, 1.0, 0, 0, "");
+                        uiDefButS(block, NUM, imagechanged, "SizeX:",  120,70,100,20, &ima->gen_x, 1.0, 5000.0, 0, 0, "Image size x");
+                        uiDefButS(block, NUM, imagechanged, "SizeY:",  220,70,90,20, &ima->gen_y, 1.0, 5000.0, 0, 0, "Image size y");
+                        uiDefButS(block, TOG, imagechanged, "UV Test grid",120,50,190,20, &ima->gen_type, 0.0, 1.0, 0, 0, "");
                         uiBlockSetFunc(block, NULL, NULL, NULL);
                 }
         }
@@ -1221,7 +1233,7 @@ static void texture_panel_image(Image **ima, ImageUser *iuser)
        uiblock_image_panel(block, ima, iuser, B_REDR, B_IMAGECHANGED);
 }      
 
-static void texture_panel_image_map(Tex *tex)
+static void texture_panel_image_map(Tex *tex, MTex *mtex)
 {
        uiBlock *block;
        
@@ -1239,12 +1251,18 @@ static void texture_panel_image_map(Tex *tex)
        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");
        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");
        uiDefButBitS(block, TOG, TEX_NEGALPHA, B_TEXPRV, "NegAlpha",    210, 160, 100, 20, &tex->flag, 0, 0, 0, 0, "Click to invert the alpha values");
-       uiBlockEndAlign(block);
 
-       uiDefButF(block, NUM, B_TEXPRV, "Filter :",                                             10,120,150,20, &tex->filtersize, 0.1, 25.0, 10, 3, "Sets the filter size used by mipmap and interpol");
+       uiBlockBeginAlign(block);
+       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");
+       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");
        
-       uiDefButBitS(block, TOG, TEX_NORMALMAP, B_NOP, "Normal Map",    160,120,150,20, &tex->imaflag,
+       uiBlockBeginAlign(block);
+       uiDefButBitS(block, TOG, TEX_NORMALMAP, B_NOP, "Normal Map",    160,120,(mtex)? 75: 150,20, &tex->imaflag,
                                        0, 0, 0, 0, "Use image RGB values for normal mapping");
+       if(mtex)
+               uiDefButS(block, MENU, B_DIFF, "Normal Space %t|Camera %x0|World %x1|Object %x2|Tangent %x3", 
+                                               235,120,75,20, &mtex->normapspace, 0, 0, 0, 0, "Sets space of normal map image");
+       uiBlockEndAlign(block);
 
        /* crop extend clip */
        
@@ -1358,7 +1376,8 @@ static void texture_panel_envmap(Tex *tex)
                        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");
                
                uiBlockBeginAlign(block);
-               uiDefButF(block, NUM, B_TEXPRV, "Filter :",                             10,65,150,20, &tex->filtersize, 0.1, 25.0, 0, 3, "Adjusts sharpness or blurriness of the reflection"),
+               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");
+               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"),
                        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"),
                        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");
                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");
@@ -1503,6 +1522,7 @@ static void texture_panel_colors(Tex *tex)
        uiNewPanelTabbed("Texture", "Texture");
        if(uiNewPanel(curarea, block, "Colors", "Texture", 1280, 0, 318, 204)==0) return;
 
+       uiSetButLock(tex->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
 
        /* COLORBAND */
        uiBlockBeginAlign(block);
@@ -1525,10 +1545,35 @@ static void texture_panel_colors(Tex *tex)
        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");
 }
 
+static int texture_channels_num_display(MTex **mtex)
+{
+       int a, num_mtex;
+
+       if(!mtex)
+               return 0;
+
+       /* compute number of texture channels to draw, 1 more
+        * than the last, used texture channel, and at least 10 */
+       num_mtex = 0;
 
-static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *la, bNode *node, Brush *br, SculptData *sd)
+       for(a=MAX_MTEX-1; a>=0; a--) {
+               if (mtex[a]) {
+                       num_mtex = a+1;
+                       break;
+               }
+       }
+
+       if (num_mtex < 10)
+               return 10;
+       else if(num_mtex < MAX_MTEX)
+               return num_mtex + 1;
+       else
+               return MAX_MTEX;
+}
+
+static void texture_panel_texture(MTex *actmtex, Material *ma, World *wrld, Lamp *la, bNode *node, Brush *br, SculptData *sd)
 {
-       MTex *mt=NULL;
+       MTex **mtex, *mt;
        uiBlock *block;
        ID *id=NULL, *idfrom;
        int a, yco, loos;
@@ -1539,17 +1584,35 @@ static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *l
        if(uiNewPanel(curarea, block, "Texture", "Texture", 320, 0, 318, 204)==0) return;
 
        /* first do the browse but */
-       if(mtex)
-               id= (ID *)mtex->tex;
+       if(actmtex)
+               id= (ID *)actmtex->tex;
        else if(node)
                id= node->id;
        
-       if(ma) idfrom= &ma->id;
-       else if(wrld) idfrom= &wrld->id;
-       else if(la) idfrom= &la->id;
-       else if(br) idfrom= &br->id;
-       else if(sd) idfrom= NULL; /* Not sure what this does */
-       else idfrom= NULL;
+       if(ma) {
+               idfrom= &ma->id;
+               mtex= ma->mtex;
+       }
+       else if(wrld) {
+               idfrom= &wrld->id;
+               mtex= wrld->mtex;
+       }
+       else if(la) {
+               idfrom= &la->id;
+               mtex= la->mtex;
+       }
+       else if(br) {
+               idfrom= &br->id;
+               mtex= br->mtex;
+       }
+       else if(sd) {
+               idfrom= NULL; /* Not sure what this does */
+               mtex= sd->mtex;
+       }
+       else {
+               idfrom= NULL;
+               mtex= NULL;
+       }
        
        uiBlockSetCol(block, TH_BUT_SETTING2);
        if(ma) {
@@ -1572,19 +1635,19 @@ static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *l
        }
        uiBlockSetCol(block, TH_BUT_NEUTRAL);
 
+       uiClearButLock();
+       
        /* From button: removed */
-
+       
        /* CHANNELS */
        if(node==NULL) {
+               int num_mtex;
                uiBlockBeginAlign(block);
                yco= 150;
-               for(a= 0; a<MAX_MTEX; a++) {
-                       
-                       if(ma) mt= ma->mtex[a];
-                       else if(wrld) mt= wrld->mtex[a];
-                       else if(la) mt= la->mtex[a];
-                       else if(br) mt= br->mtex[a];
-                       else if(sd) mt= sd->mtex[a];
+               
+               num_mtex= texture_channels_num_display(mtex);
+               for(a=0; a<num_mtex; a++) {
+                       mt= mtex[a];
                        
                        if(mt && mt->tex) splitIDname(mt->tex->id.name+2, str, &loos);
                        else strcpy(str, "");
@@ -1655,11 +1718,11 @@ static void texture_panel_preview(MTex *mtex, int preview)
        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");
        uiBlockEndAlign(block);
        
-       if(mtex && mtex->tex)
-               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");
-       
-       uiDefBut(block, BUT, B_DEFTEXVAR, "Default Vars",200,10,80,20, 0, 0, 0, 0, 0, "Sets all values to defaults");
-
+       if(mtex && mtex->tex) {
+               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");   
+               uiSetButLock(mtex->tex->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
+               uiDefBut(block, BUT, B_DEFTEXVAR, "Default Vars",200,10,80,20, 0, 0, 0, 0, 0, "Sets all values to defaults");
+       }
 }
 
 
@@ -1879,6 +1942,7 @@ void do_worldbuts(unsigned short event)
        static MTex mtexcopybuf;
        World *wrld;
        MTex *mtex;
+       MTex *mtexswap;
        
        switch(event) {
        case B_TEXCLEARWORLD:
@@ -1923,6 +1987,26 @@ void do_worldbuts(unsigned short event)
                        scrarea_queue_winredraw(curarea);
                }
                break;
+       case B_WMTEXMOVEUP:
+               wrld= G.buts->lockpoin;
+               if(wrld && (int)wrld->texact > 0) {
+                       mtexswap = wrld->mtex[(int)wrld->texact];
+                       wrld->mtex[(int)wrld->texact] = wrld->mtex[((int)wrld->texact)-1];
+                       wrld->mtex[((int)wrld->texact)-1] = mtexswap;
+                       wrld->texact--;
+                       allqueue(REDRAWBUTSSHADING, 0);
+               }
+               break;
+       case B_WMTEXMOVEDOWN:
+               wrld= G.buts->lockpoin;
+               if(wrld && (int)wrld->texact < MAX_MTEX-1) {
+                       mtexswap = wrld->mtex[(int)wrld->texact];
+                       wrld->mtex[(int)wrld->texact] = wrld->mtex[((int)wrld->texact)+1];
+                       wrld->mtex[((int)wrld->texact)+1] = mtexswap;
+                       wrld->texact++;
+                       allqueue(REDRAWBUTSSHADING, 0);
+               }
+               break;
        case B_AO_FALLOFF:
                /* falloff distances option only supports plain */
                wrld= G.buts->lockpoin;
@@ -1964,7 +2048,7 @@ static void world_panel_mapto(World *wrld)
        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");
        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");
        uiBlockEndAlign(block);
-       uiDefButF(block, NUMSLI, B_WORLDPRV, "DVar ",           10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "The default value for textures to mix with values (not RGB)");
+       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");
        
        /* MAP TO */
        uiBlockBeginAlign(block);
@@ -1990,7 +2074,7 @@ static void world_panel_texture(World *wrld)
        uiBlock *block;
        MTex *mtex;
        ID *id;
-       int a, loos;
+       int a, loos, num_mtex;
        char str[64], *strp;
        
        block= uiNewBlock(&curarea->uiblocks, "world_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
@@ -2001,7 +2085,8 @@ static void world_panel_texture(World *wrld)
        /* TEX CHANNELS */
        uiBlockSetCol(block, TH_BUT_NEUTRAL);
        uiBlockBeginAlign(block);
-       for(a= 0; a<MAX_MTEX; a++) {
+       num_mtex= texture_channels_num_display(wrld->mtex);
+       for(a= 0; a<num_mtex; a++) {
                mtex= wrld->mtex[a];
                if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
                else strcpy(str, "");
@@ -2027,24 +2112,26 @@ static void world_panel_texture(World *wrld)
        if(id) {
                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");
                sprintf(str, "%d", id->us);
-               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");
-               uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 220,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
+               uiDefBut(block, BUT, 0, str,                    177,140,21,19, 0, 0, 0, 0, 0, "Displays number of users of texture: click to make single user");
+               uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 155,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
                if(id->lib) {
                        if(wrld->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,      219,140,21,19, 0, 0, 0, 0, 0, "");
                        else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
                }
                uiBlockSetCol(block, TH_AUTO);
-               uiDefBut(block, BUT, B_TEXCLEARWORLD, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erases link to texture");
+               uiDefBut(block, BUT, B_TEXCLEARWORLD, "Clear", 122, 140, 32, 19, 0, 0, 0, 0, 0, "Erases link to texture");
        }
        else 
                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");
 
        uiBlockSetCol(block, TH_AUTO);
        
-       /* copy/paste */
+       /* copy/paste/up/down */
        uiBlockBeginAlign(block);
-       uiDefIconBut(block, BUT, B_WMTEXCOPY, ICON_COPYUP,      250,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
-       uiDefIconBut(block, BUT, B_WMTEXPASTE, ICON_PASTEUP,275,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
+       uiDefIconBut(block, BUT, B_WMTEXCOPY, ICON_COPYUP,      200,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
+       uiDefIconBut(block, BUT, B_WMTEXPASTE, ICON_PASTEUP,    225,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
+       uiDefIconBut(block, BUT, B_WMTEXMOVEUP, VICON_MOVE_UP,  250,140,25,19, 0, 0, 0, 0, 0, "Move texture channel up");
+       uiDefIconBut(block, BUT, B_WMTEXMOVEDOWN, VICON_MOVE_DOWN, 275,140,25,19, 0, 0, 0, 0, 0, "Move texture channel down");
                
        /* TEXCO */
        uiBlockBeginAlign(block);
@@ -2098,13 +2185,13 @@ static void world_panel_mistaph(World *wrld)
        uiBlockSetCol(block, TH_AUTO);
 
        uiBlockBeginAlign(block);
-       uiDefButS(block, ROW, B_WORLDPRV2, "Qua", 10, 90, 40, 19, &wrld->mistype, 1.0, 0.0, 0, 0, "Mist uses quadratic progression");
+       uiDefButS(block, ROW, B_WORLDPRV2, "Quad", 10, 90, 40, 19, &wrld->mistype, 1.0, 0.0, 0, 0, "Mist uses quadratic progression");
        uiDefButS(block, ROW, B_WORLDPRV2, "Lin", 50, 90, 50, 19, &wrld->mistype, 1.0, 1.0, 0, 0, "Mist uses linear progression");
        uiDefButS(block, ROW, B_WORLDPRV2, "Sqr", 100, 90, 50, 19, &wrld->mistype, 1.0, 2.0, 0, 0, "Mist uses inverse quadratic progression");
        uiBlockBeginAlign(block);
-       uiDefButF(block, NUM,B_WORLDPRV2, "Sta:",10,70,140,19, &wrld->miststa, 0.0, 10000.0, 10, 0, "Specifies the starting distance of the mist");
-       uiDefButF(block, NUM,B_WORLDPRV2, "Di:",10,50,140,19, &wrld->mistdist, 0.0,10000.0, 10, 00, "Specifies the depth of the mist");
-       uiDefButF(block, NUM,B_WORLDPRV2,"Hi:",         10,30,140,19, &wrld->misthi,0.0,100.0, 10, 0, "Specifies the factor for a less dense mist with increasing height");
+       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");
+       uiDefButF(block, NUM,B_WORLDPRV2, "Dist:",10,50,140,19, &wrld->mistdist, 0.0,10000.0, 10, 00, "Specifies the depth of the mist");
+       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");
        uiDefButF(block, NUMSLI, B_WORLDPRV2, "Misi ",          10,10,140,19,   &(wrld->misi), 0., 1.0, 0, 0, "Sets the mist intensity");
        uiBlockEndAlign(block);
 
@@ -2129,25 +2216,36 @@ static void world_panel_amb_occ(World *wrld)
        block= uiNewBlock(&curarea->uiblocks, "world_panel_amb_oc", UI_EMBOSS, UI_HELV, curarea->win);
        uiNewPanelTabbed("Mist / Stars / Physics", "World");
        if(uiNewPanel(curarea, block, "Amb Occ", "World", PANELX, PANELY, PANELW, PANELH)==0) return;
-
+       uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
+       
+       
        uiBlockSetCol(block, TH_BUT_SETTING1);
        uiDefButBitS(block, TOG, WO_AMB_OCC, B_REDR, "Ambient Occlusion",
                X2CLM1, yco-=BUTH, BUTW1, BUTH, &wrld->mode, 0, 0, 0, 0, "Toggles ambient occlusion (soft shadows)");
        uiBlockSetCol(block, TH_AUTO);
        
        if(!(wrld->mode & WO_AMB_OCC)) return;
-       
-       yco -= YSPACE;
 
-       uiDefButS(block, NUM, B_REDR, "Samples:",
-               X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aosamp, 1.0, 32.0, 100, 0, "Sets the number of samples used for AO  (actual number: squared)");
-       
        yco -= YSPACE;
-       
-       uiDefButF(block, NUM, B_REDR, "Max Dist:",
-               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");
 
-       yco -= YSPACE;
+       if(wrld->ao_gather_method == WO_AOGATHER_RAYTRACE) {
+               uiDefButS(block, NUM, B_REDR, "Samples:",
+                       X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aosamp, 1.0, 32.0, 100, 0, "Sets the number of samples used for AO  (actual number: squared)");
+
+               yco -= YSPACE;
+               
+               uiDefButF(block, NUM, B_REDR, "Max Dist:",
+                       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");
+       }
+       else {
+               uiDefButS(block, NUM, B_REDR, "Passes:",
+                       X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->ao_approx_passes, 0.0, 10.0, 0, 0, "Sets the number of preprocessing passes to reduce overocclusion");
+
+               yco -= YSPACE;
+       
+               uiDefButF(block, NUM, B_REDR, "Correction:",
+                       X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->ao_approx_correction, 0.0, 1.0, 0, 0, "Ad-hoc correction for over-occlusion due to the approximation.");
+       }
        
        uiBlockBeginAlign(block);
        uiDefButBitS(block, TOG, WO_AODIST, B_AO_FALLOFF, "Use Falloff",
@@ -2160,24 +2258,39 @@ static void world_panel_amb_occ(World *wrld)
        /* column 2 */
        yco = PANEL_YMAX - BUTH - YSPACE;
        
-       uiDefButS(block, MENU, B_REDR, "Constant QMC %x2|Adaptive QMC %x1|Constant Jittered %x0",
-               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");
-       
+       uiDefButS(block, MENU, B_REDR, "Gather Method%t|Raytrace %x0|Approximate %x1",
+               X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->ao_gather_method, 0, 0, 0, 0, "Method for occlusion gathering: Raytrace: slow when noise free results are required, but accurate, Approximate: faster and without noise, but inaccurate");
+
        yco -= YSPACE;
-       
-       if (wrld->ao_samp_method == WO_AOSAMP_HALTON) { 
+
+       if(wrld->ao_gather_method == WO_AOGATHER_RAYTRACE) {
+               uiDefButS(block, MENU, B_REDR, "Constant QMC %x2|Adaptive QMC %x1|Constant Jittered %x0",
+                       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");
+               
+               yco -= YSPACE;
+
+               if (wrld->ao_samp_method == WO_AOSAMP_HALTON) { 
+                       uiBlockBeginAlign(block);
+                       uiDefButF(block, NUM, B_REDR, "Threshold:",
+                               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");
+                       uiDefButF(block, NUMSLI, B_REDR, "Adapt Vec:",
+                               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.");
+                       uiBlockEndAlign(block);
+               } else if (wrld->ao_samp_method == WO_AOSAMP_CONSTANT) {
+                       uiDefButF(block, NUMSLI, B_REDR, "Bias:",
+                               X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->aobias, 0.0, 0.5, 10, 0, "Sets bias to prevent smoothed faces to show banding (in radians)");
+               }
+       }
+       else {
                uiBlockBeginAlign(block);
-               uiDefButF(block, NUM, B_REDR, "Threshold:",
-                       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");
-               uiDefButF(block, NUMSLI, B_REDR, "Adapt Vec:",
-                       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.");
+               uiDefButF(block, NUM, B_REDR, "Error:",
+                       X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->ao_approx_error, 0.0001, 10.0, 0, 0, "Error tolerance (low values are slower and higher quality)");
+
+               uiDefButBitS(block, TOG, WO_AOCACHE, B_REDR, "Pixel Cache",
+                       X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->aomode, 0, 0, 0, 0, "Cache AO results in pixels and interpolate over neighbouring pixels for speedup.");
                uiBlockEndAlign(block);
-       } else if (wrld->ao_samp_method == WO_AOSAMP_CONSTANT) {
-               uiDefButF(block, NUMSLI, B_REDR, "Bias:",
-                       X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->aobias, 0.0, 0.5, 10, 0, "Sets bias to prevent smoothed faces to show banding (in radians)");
        }
 
-
        yco = PANEL_YMAX - (5*BUTH+4*YSPACE);
 
        /* result mix modes */
@@ -2188,6 +2301,7 @@ static void world_panel_amb_occ(World *wrld)
                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)");
        uiDefButS(block, ROW, B_REDR, "Both",
                X3CLM3, yco, BUTW3, BUTH, &wrld->aomix, 1.0, (float)WO_AOADDSUB, 0, 0, "both lightens & darkens");
+       uiBlockEndAlign(block);
 
        yco -= YSPACE;
 
@@ -2197,15 +2311,15 @@ static void world_panel_amb_occ(World *wrld)
                X3CLM1, yco-=BUTH, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOPLAIN, 0, 0, "Plain diffuse energy (white)");
        uiDefButS(block, ROW, B_REDR, "Sky Color", 
                X3CLM2, yco, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOSKYCOL, 0, 0, "Use horizon and zenith color for diffuse energy");
-       uiDefButS(block, ROW, B_REDR, "Sky Texture", 
-               X3CLM3, yco, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOSKYTEX, 0, 0, "Does full Sky texture render for diffuse energy");
+       if(wrld->ao_gather_method == WO_AOGATHER_RAYTRACE)
+               uiDefButS(block, ROW, B_REDR, "Sky Texture", 
+                       X3CLM3, yco, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOSKYTEX, 0, 0, "Does full Sky texture render for diffuse energy");
        uiBlockEndAlign(block);
-       
+
        yco -= YSPACE;
-       
+               
        uiDefButF(block, NUMSLI, B_REDR, "Energy:",
                X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aoenergy, 0.01, 3.0, 100, 0, "Sets global energy scale for AO");
-       
 }
 
 static void world_panel_world(World *wrld)
@@ -2223,28 +2337,28 @@ static void world_panel_world(World *wrld)
        uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
        uiBlockSetCol(block, TH_AUTO);
 
-       uiDefButF(block, COL, B_WORLDPRV, "",                   10,150,145,19, &wrld->horr, 0, 0, 0, B_COLHOR, "");
-       uiDefButF(block, COL, B_WORLDPRV, "",                   160,150,145,19, &wrld->zenr, 0, 0, 0, B_COLZEN, "");
-
        uiBlockBeginAlign(block);
+       uiDefButF(block, COL, B_WORLDPRV, "",                   10,150,145,19, &wrld->horr, 0, 0, 0, B_COLHOR, "");
        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");
        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");
        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");
        
        uiBlockBeginAlign(block);
+       uiDefButF(block, COL, B_WORLDPRV, "",                   160,150,145,19, &wrld->zenr, 0, 0, 0, B_COLZEN, "");
        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");
        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");
        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");
 
        uiBlockBeginAlign(block);
+       uiDefButF(block, COL, B_WORLDPRV, "",           10,70,145,19, &wrld->ambr, 0, 0, 0, 0, "");
        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");
        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");
        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");
 
        uiBlockBeginAlign(block);
        uiBlockSetCol(block, TH_BUT_SETTING1);
-       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");
-       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");
+       uiDefButF(block, NUMSLI,B_WORLDPRV2, "Exp ",                    160,30,145,19,  &(wrld->exp), 0.0, 1.0, 0, 2, "Sets amount of exponential color correction for light");
+       uiDefButF(block, NUMSLI,B_WORLDPRV2, "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");
 
 
 }
@@ -2267,9 +2381,11 @@ static void world_panel_preview(World *wrld)
        uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
 
        uiBlockBeginAlign(block);
-       uiDefButBitS(block, TOG, WO_SKYREAL, B_WORLDPRV,"Real", 200,175,80,25, &wrld->skytype, 0, 0, 0, 0, "Renders background with a real horizon");
-       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");
-       uiDefButBitS(block, TOG,WO_SKYPAPER, B_WORLDPRV,"Paper",200,125,80,25, &wrld->skytype, 0, 0, 0, 0, "Flattens blend or texture coordinates");
+       uiDefButBitS(block, TOG, WO_SKYBLEND, B_WORLDPRV,"Blend", 220,175,100,25, &wrld->skytype, 0, 0, 0, 0, "Renders background with natural progression from horizon to zenith");
+       uiDefButBitS(block, TOG,WO_SKYPAPER, B_WORLDPRV,"Paper", 220,150,100,25, &wrld->skytype, 0, 0, 0, 0, "Flattens blend or texture coordinates");
+       /*if (wrld->skytype & WO_SKYBLEND) {*/ /* In some (rare?) cases its possible to use this, leave this out for now */
+               uiDefButBitS(block, TOG, WO_SKYREAL, B_WORLDPRV,"Real", 220,125,100,25, &wrld->skytype, 0, 0, 0, 0, "Renders background with a real horizon");
+       /*}*/
        uiBlockEndAlign(block);
 
 }
@@ -2282,6 +2398,7 @@ void do_lampbuts(unsigned short event)
        static MTex mtexcopybuf;
        Lamp *la;
        MTex *mtex;
+       MTex *mtexswap;
 
        switch(event) {
        case B_LAMPREDRAW:
@@ -2352,6 +2469,26 @@ void do_lampbuts(unsigned short event)
                        scrarea_queue_winredraw(curarea);
                }
                break;
+       case B_LMTEXMOVEUP:
+               la= G.buts->lockpoin;
+               if(la && (int)la->texact > 0) {
+                       mtexswap = la->mtex[(int)la->texact];
+                       la->mtex[(int)la->texact] = la->mtex[((int)la->texact)-1];
+                       la->mtex[((int)la->texact)-1] = mtexswap;
+                       la->texact--;
+                       allqueue(REDRAWBUTSSHADING, 0);
+               }
+               break;
+       case B_LMTEXMOVEDOWN:
+               la= G.buts->lockpoin;
+               if(la && (int)la->texact < MAX_MTEX-1) {
+                       mtexswap = la->mtex[(int)la->texact];
+                       la->mtex[(int)la->texact] = la->mtex[((int)la->texact)+1];
+                       la->mtex[((int)la->texact)+1] = mtexswap;
+                       la->texact++;
+                       allqueue(REDRAWBUTSSHADING, 0);
+               }
+               break;
        case B_LFALLOFFCHANGED:
                la= G.buts->lockpoin;
                curvemapping_changed(la->curfalloff, 1);
@@ -2395,7 +2532,7 @@ static void lamp_panel_mapto(Object *ob, Lamp *la)
        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");
        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");
        uiBlockEndAlign(block);
-       uiDefButF(block, NUMSLI, B_LAMPPRV, "DVar ",                    10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "The default value the textures uses to mix with");
+       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");
        
        /* MAP TO */
        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,7 +2551,7 @@ static void lamp_panel_texture(Object *ob, Lamp *la)
        uiBlock *block;
        MTex *mtex;
        ID *id;
-       int a, loos;
+       int a, loos, num_mtex;
        char *strp, str[64];
        
        block= uiNewBlock(&curarea->uiblocks, "lamp_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
@@ -2425,7 +2562,8 @@ static void lamp_panel_texture(Object *ob, Lamp *la)
        /* TEX CHANNELS */
        uiBlockSetCol(block, TH_BUT_NEUTRAL);
        uiBlockBeginAlign(block);
-       for(a= 0; a<MAX_MTEX; a++) {
+       num_mtex= texture_channels_num_display(la->mtex);
+       for(a= 0; a<num_mtex; a++) {
                mtex= la->mtex[a];
                if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
                else strcpy(str, "");
@@ -2453,22 +2591,25 @@ static void lamp_panel_texture(Object *ob, Lamp *la)
        if(id) {
                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");
                sprintf(str, "%d", id->us);
-               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");
-               uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 221,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
+               uiDefBut(block, BUT, 0, str,                    155,140,21,19, 0, 0, 0, 0, 0, "Displays number of users of texture: click to make single user");
+               uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 177,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
                if(id->lib) {
                        if(la->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,140,21,19, 0, 0, 0, 0, 0, "");
                        else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
                }
                uiBlockSetCol(block, TH_AUTO);
-               uiDefBut(block, BUT, B_TEXCLEARLAMP, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erases link to texture");
+               uiDefBut(block, BUT, B_TEXCLEARLAMP, "Clear", 122, 140, 32, 19, 0, 0, 0, 0, 0, "Erases link to texture");
        }
        else 
                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");
 
-       /* copy/paste */
+       /* copy/paste/up/down */
        uiBlockBeginAlign(block);
-       uiDefIconBut(block, BUT, B_LMTEXCOPY, ICON_COPYUP,      250,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
-       uiDefIconBut(block, BUT, B_LMTEXPASTE, ICON_PASTEUP,    275,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
+       uiDefIconBut(block, BUT, B_LMTEXCOPY, ICON_COPYUP,      200,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
+       uiDefIconBut(block, BUT, B_LMTEXPASTE, ICON_PASTEUP,    225,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
+       uiDefIconBut(block, BUT, B_LMTEXMOVEUP, VICON_MOVE_UP, 250,140,25,19, 0, 0, 0, 0, 0, "Move texture channel up");
+       uiDefIconBut(block, BUT, B_LMTEXMOVEDOWN, VICON_MOVE_DOWN, 275,140,25,19, 0, 0, 0, 0, 0, "Move texture channel down");
+
        
        /* TEXCO */
        uiBlockSetCol(block, TH_AUTO);
@@ -2495,7 +2636,7 @@ static void lamp_panel_spot(Object *ob, Lamp *la)
        float grid=0.0;
        
        block= uiNewBlock(&curarea->uiblocks, "lamp_panel_spot", UI_EMBOSS, UI_HELV, curarea->win);
-       if(uiNewPanel(curarea, block, "Shadow and Spot", "Lamp", 640, 0, 318, 204)==0) return;
+       if(uiNewPanel(curarea, block, "Shadow and Spot", "Lamp", 640, 0, 318, 224)==0) return;
 
        /* hemis and ray shadow dont work at all... */
        /* yafray: ignore photonlight as well */
@@ -2508,9 +2649,9 @@ static void lamp_panel_spot(Object *ob, Lamp *la)
 
        uiBlockSetCol(block, TH_BUT_SETTING1);
        uiBlockBeginAlign(block);
-       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");
+       uiDefButBitI(block, TOG, LA_SHAD_RAY, B_SHADRAY,"Ray Shadow",10,180,80,19,&la->mode, 0, 0, 0, 0, "Use ray tracing for shadow");
        if(la->type==LA_SPOT) {
-               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");
+               uiDefButBitI(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");
                if(la->mode & LA_SHAD_BUF) {
                        char *tip= "Regular buffer type";
                        if(la->buftype==LA_SHADBUF_IRREGULAR)
@@ -2523,12 +2664,15 @@ static void lamp_panel_spot(Object *ob, Lamp *la)
        }
        uiBlockEndAlign(block);
        
-       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");
+       uiBlockBeginAlign(block);
+       uiDefButBitI(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");
+       uiDefButBitI(block, TOG, LA_LAYER_SHADOW, B_LAMPPRV,"Layer",            10,90,80,19,&la->mode, 0, 0, 0, 0, "Causes only objects on the same layer to cast shadows");
+       uiBlockEndAlign(block);
 
        if(la->type==LA_SPOT) {
                uiBlockBeginAlign(block);
-               uiDefButBitS(block, TOG, LA_SQUARE, B_LAMPREDRAW,"Square",      10,60,80,19,&la->mode, 0, 0, 0, 0, "Sets square spotbundles");
-               uiDefButBitS(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",          10,40,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
+               uiDefButBitI(block, TOG, LA_SQUARE, B_LAMPREDRAW,"Square",      10,60,80,19,&la->mode, 0, 0, 0, 0, "Sets square spotbundles");
+               uiDefButBitI(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",          10,40,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
 
                uiBlockBeginAlign(block);
                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");
@@ -2545,9 +2689,10 @@ static void lamp_panel_spot(Object *ob, Lamp *la)
                                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");
                                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");
                                
-       //                      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");
-       //                      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");
-       //                      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");
+                               uiBlockBeginAlign(block);
+                               uiDefButS(block, ROW,B_NOP,"SampleBuffers: 1",  100,-15,140,19, &la->buffers, 1.0, 1.0, 0, 0, "Only one lampbuffer rendered");
+                               uiDefButS(block, ROW,B_NOP,"4",                                 240,-15,30,19, &la->buffers, 1.0, 4.0, 0, 0, "Renders 4 lampbuffers for better AA, this quadruples memory usage");
+                               uiDefButS(block, ROW,B_NOP,"9",                                 270,-15,30,19, &la->buffers, 1.0, 9.0, 0, 0, "Renders 9 lampbuffers for better AA, this uses nine times more memory");
                        
                                uiBlockBeginAlign(block);
                                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");
@@ -2556,7 +2701,7 @@ static void lamp_panel_spot(Object *ob, Lamp *la)
                                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");
                        }
                        else {  /* LA_SHADBUF_IRREGULAR */
-                               uiDefButF(block, NUM,B_LAMPREDRAW,"Bias:",              100,40,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Sets the shadow map sampling bias");
+                               uiDefButF(block, NUM,B_LAMPREDRAW,"Bias:",              100,40,100,19,  &la->bias, 0.001, 5.0, 1, 0, "Sets the shadow map sampling bias");
                        }
                        
                        uiBlockBeginAlign(block);
@@ -2585,7 +2730,8 @@ static void lamp_panel_spot(Object *ob, Lamp *la)
                        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");
                        
                        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)");
-                       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");
+                       if (la->ray_samp_method == LA_SAMP_HALTON)
+                               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");
                }
                else if (la->type == LA_AREA) {
                        uiDefButS(block, MENU, B_REDR, "Adaptive QMC %x1|Constant QMC %x2|Constant Jittered %x0",
@@ -2650,12 +2796,12 @@ static void lamp_panel_yafray(Object *ob, Lamp *la)
        /* in yafray arealights always cast shadows, so ray shadow flag not needed */
        /* ray shadow also not used when halo for spot enabled */
        if ((la->type!=LA_AREA) && (!((la->type==LA_SPOT) && (la->mode & LA_HALO))))
-               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");
+               uiDefButBitI(block, TOG, LA_SHAD_RAY, B_SHADRAY,"Ray Shadow",10,180,80,19,&la->mode, 0, 0, 0, 0, "Use ray tracing for shadow");
        
        /* in yafray the regular lamp can use shadowbuffers (softlight), used by spot with halo as well */
        /* to prevent clash with blender shadowbuf flag, a special flag is used for yafray */
        if (la->type==LA_LOCAL) {
-               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");
+               uiDefButBitI(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");
                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");
                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");
                uiDefButS(block, NUM, B_DIFF, "GlowType:", 200,135,100,19, &la->YF_glowtype, 0, 1, 1, 0, "Sets light glow type");
@@ -2683,7 +2829,7 @@ static void lamp_panel_yafray(Object *ob, Lamp *la)
        
        if (la->type==LA_SPOT) {
 
-               uiDefButBitS(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",                          10,50,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
+               uiDefButBitI(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",                          10,50,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
 
                uiBlockSetCol(block, TH_AUTO);
                uiBlockBeginAlign(block);
@@ -2706,6 +2852,42 @@ static void lamp_panel_yafray(Object *ob, Lamp *la)
 
 }
 
+static void lamp_panel_atmosphere(Object *ob, Lamp *la)
+{
+       uiBlock *block;
+       int y;
+       block= uiNewBlock(&curarea->uiblocks, "lamp_panel_atm", UI_EMBOSS, UI_HELV, curarea->win);
+       uiNewPanelTabbed("Shadow and Spot", "Lamp");
+       if(uiNewPanel(curarea, block, "Sky/Atmosphere", "Lamp", 3*PANELX, PANELY, PANELW, PANELH)==0) return;
+
+       uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
+       
+       uiDefButBitS(block, TOG, LA_SUN_EFFECT_SKY, REDRAWVIEW3D, "Sky", 10,205,BUTW2,20,&(la->sun_effect_type), 0, 0, 0, 0, "Apply sun light effect on sky.");
+       uiDefButBitS(block, TOG, LA_SUN_EFFECT_AP, REDRAWVIEW3D, "Atmosphere", 20+BUTW2,205,BUTW2,20,&(la->sun_effect_type), 0, 0, 0, 0, "Apply sun light effect on atmosphere.");
+
+       if(la->sun_effect_type & (LA_SUN_EFFECT_SKY|LA_SUN_EFFECT_AP)){
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Turbidity:",10,180,BUTW1,19, &(la->atm_turbidity), 1.000f, 30.0f, 1, 0, "Sky Turbidity");
+       }
+
+       y = 180;
+       if(la->sun_effect_type & LA_SUN_EFFECT_SKY)
+       {
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Hor.Bright:",10,y-25,BUTW2,19, &(la->horizon_brightness), 0.00f, 20.00f, 10, 0, "Sets horizon brightness.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Hor.Spread:",10,y-50,BUTW2,19, &(la->spread), 0.00f, 10.00f, 10, 0, "Sets horizon spread.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Sun Bright:",10,y-75,BUTW2,19, &(la->sun_brightness), 0.00f, 10.0f, 10, 0, "Sets sun brightness.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Sun Size:",10,y-100,BUTW2,19, &(la->sun_size), 0.00f, 10.00f, 10, 0, "Sets sun size.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Back Light:",10,y-125,BUTW2,19, &(la->backscattered_light), -1.00f, 1.00f, 10, 0, "Sets backscatter light.");
+       }
+
+       if(la->sun_effect_type & LA_SUN_EFFECT_AP)
+       {
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Sun Intens.:",20+BUTW2,y-25,BUTW2,19, &(la->sun_intensity), 0.00f, 10.00f, 10, 0, "Sets sun intensity.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Inscattering:",20+BUTW2,y-50,BUTW2,19, &(la->atm_inscattering_factor), 0.00f, 1.00f, 10, 0, "In Scattering Contribution Factor.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Extinction:",20+BUTW2,y-75,BUTW2,19, &(la->atm_extinction_factor), 0.00f, 1.00f, 10, 0, "Extinction Scattering Contribution Factor.");
+               uiDefButF(block, NUM, B_LAMPREDRAW, "Distance:",20+BUTW2,y-100,BUTW2,19, &(la->atm_distance_factor), 0.000f, 500.0f, 10, 0, "Scale blender distance to real distance.");
+       }
+}
+
 static void lamp_panel_falloff(Object *ob, Lamp *la)
 {
        uiBlock *block;
@@ -2767,15 +2949,15 @@ static void lamp_panel_lamp(Object *ob, Lamp *la)
                uiBlockSetCol(block, TH_BUT_SETTING1);
                uiDefButS(block, MENU, B_LAMPREDRAW,  "Falloff %t|Constant %x0|Inverse Linear %x1|Inverse Square %x2|Custom Curve %x3|Lin/Quad Weighted %x4|",
                        10,150,100,19, &la->falloff_type, 0,0,0,0, "Lamp falloff - intensity decay with distance");     
-               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");
+               uiDefButBitI(block, TOG, LA_SPHERE, B_LAMPPRV,"Sphere", 10,130,100,19,&la->mode, 0, 0, 0, 0, "Sets light intensity to zero for objects beyond the distance value");
        }
 
        uiBlockBeginAlign(block);
        uiBlockSetCol(block, TH_BUT_SETTING1);
-       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");
-       uiDefButBitS(block, TOG, LA_NEG, B_LAMPPRV,"Negative",  10,50,100,19,&la->mode, 0, 0, 0, 0, "Sets lamp to cast negative light");
-       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");
-       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");
+       uiDefButBitI(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");
+       uiDefButBitI(block, TOG, LA_NEG, B_LAMPPRV,"Negative",  10,50,100,19,&la->mode, 0, 0, 0, 0, "Sets lamp to cast negative light");
+       uiDefButBitI(block, TOG, LA_NO_DIFF, B_LAMPPRV,"No Diffuse",            10,30,100,19,&la->mode, 0, 0, 0, 0, "Disables diffuse shading of material illuminated by this lamp");
+       uiDefButBitI(block, TOG, LA_NO_SPEC, B_LAMPPRV,"No Specular",           10,10,100,19,&la->mode, 0, 0, 0, 0, "Disables specular shading of material illuminated by this lamp");
        uiBlockEndAlign(block);
 
        uiBlockSetCol(block, TH_AUTO);
@@ -2791,8 +2973,8 @@ static void lamp_panel_lamp(Object *ob, Lamp *la)
        
        uiBlockBeginAlign(block);
        if (ELEM(la->type, LA_LOCAL, LA_SPOT) && (la->falloff_type == LA_FALLOFF_SLIDERS)) {
-               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");
-               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");
+               uiDefButF(block, NUMSLI,B_LAMPPRV,"Linear ",    120,30,180,19,&la->att1, 0.0, 1.0, 0, 0, "Set the linear distance attenuation for a Lin/Quad Weighted lamp");
+               uiDefButF(block, NUMSLI,B_LAMPPRV,"Quad ",  120,10,180,19,&la->att2, 0.0, 1.0, 0, 0, "Set the quadratic distance attenuation for a Lin/Quad Weighted lamp");
        }
        else if(la->type==LA_AREA) {
                if(la->k==0.0) la->k= 1.0;
@@ -2836,6 +3018,7 @@ void do_matbuts(unsigned short event)
        static MTex mtexcopybuf;
        Material *ma;
        MTex *mtex;
+       MTex *mtexswap;
 
        /* all operations default on active material layer here */
        /* but this also gets called for lamp and world... */
@@ -2922,13 +3105,14 @@ void do_matbuts(unsigned short event)
        case B_LAMPPRV:
                BIF_preview_changed(ID_LA);
                allqueue(REDRAWBUTSSHADING, 0);
+               shade_buttons_change_3d();
                break;
        case B_WORLDPRV:
                BIF_preview_changed(ID_WO);
                allqueue(REDRAWBUTSSHADING, 0);
                break;
        case B_WORLDPRV2:
-               BIF_preview_changed(ID_WO);
+               BIF_preview_changed(ID_TE);
                allqueue(REDRAWBUTSSHADING, 0);
                allqueue(REDRAWVIEW3D, 0);
                break;
@@ -2984,6 +3168,34 @@ void do_matbuts(unsigned short event)
                        scrarea_queue_winredraw(curarea);
                }
                break;
+       case B_MTEXMOVEUP:
+               if(ma && (int)ma->texact > 0) {
+                       int mtexuse = ma->septex & (1<<((int)ma->texact));
+                       ma->septex &= ~(1<<((int)ma->texact));
+                       ma->septex |= (ma->septex & (1<<((int)ma->texact-1))) << 1;
+                       ma->septex &= ~(1<<((int)ma->texact-1));
+                       ma->septex |= mtexuse >> 1;
+                       mtexswap = ma->mtex[(int)ma->texact];
+                       ma->mtex[(int)ma->texact] = ma->mtex[((int)ma->texact)-1];
+                       ma->mtex[((int)ma->texact)-1] = mtexswap;
+                       ma->texact--;
+                       allqueue(REDRAWBUTSSHADING, 0);
+               }
+               break;
+       case B_MTEXMOVEDOWN:
+               if(ma && (int)ma->texact < MAX_MTEX-1) {
+                       int mtexuse = ma->septex & (1<<((int)ma->texact));
+                       ma->septex &= ~(1<<((int)ma->texact));
+                       ma->septex |= (ma->septex & (1<<((int)ma->texact+1))) >> 1;
+                       ma->septex &= ~(1<<((int)ma->texact+1));
+                       ma->septex |= mtexuse << 1;
+                       mtexswap = ma->mtex[(int)ma->texact];
+                       ma->mtex[(int)ma->texact] = ma->mtex[((int)ma->texact)+1];
+                       ma->mtex[((int)ma->texact)+1] = mtexswap;
+                       ma->texact++;
+                       allqueue(REDRAWBUTSSHADING, 0);
+               }
+               break;
        case B_MATZTRANSP:
                if(ma) {
                        ma->mode &= ~MA_RAYTRANSP;
@@ -3040,16 +3252,65 @@ void do_matbuts(unsigned short event)
                        allqueue(REDRAWBUTSSHADING, 0);
                }
                break;
-               
+
+       case B_MAT_PARTICLE:
+               if(ma) {
+                       Base *base;
+                       Object *ob;
+                       ParticleSystem *psys;
+
+                       base= G.scene->base.first;
+                       while(base){
+                               if(base->object->type==OB_MESH) {
+                                       ob=base->object;
+                                       for(psys=ob->particlesystem.first; psys; psys=psys->next) {
+                                               if(psys && ma==give_current_material(ob,psys->part->omat)) {
+                                                       psys->recalc |= PSYS_INIT | PSYS_RECALC_HAIR;
+
+                                                       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+                                               }
+                                       }
+                               }
+                               base = base->next;
+                       }
+                       allqueue(REDRAWVIEW3D, 0);
+               }
        }
 }
 
+static void particle_recalc_material(void *ma_v, void *arg2)
+{
+       Material *ma = ma_v;
+       Base *base;
+       Object *ob;
+       ParticleSystem *psys;
+
+       base= G.scene->base.first;
+       while(base){
+               if(base->object->type==OB_MESH){
+                       ob=base->object;
+                       for(psys=ob->particlesystem.first; psys; psys=psys->next){
+                               if(psys && ma==give_current_material(ob,psys->part->omat)){
+                                       psys->recalc |= PSYS_INIT | PSYS_RECALC_HAIR;
+
+                                       DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
+                               }
+                       }
+               }
+               base = base->next;
+       }
+       allqueue(REDRAWVIEW3D, 0);
+}
 
 /* if from nodes, hide options that are not available */
-static void material_panel_map_to(Material *ma, int from_nodes)
+static void material_panel_map_to(Object *ob, Material *ma, int from_nodes)
 {
        uiBlock *block;
+       uiBut *but;
        MTex *mtex;
+       ParticleSystem *psys;
+       int psys_mapto=0;
+       static short pattr=0;
        
        block= uiNewBlock(&curarea->uiblocks, "material_panel_map_to", UI_EMBOSS, UI_HELV, curarea->win);
        uiNewPanelTabbed("Texture", "Material");
@@ -3086,37 +3347,93 @@ static void material_panel_map_to(Material *ma, int from_nodes)
                uiDefButF(block, NUMSLI, B_MATPRV, "B ",                10,40,135,19, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
        }
        uiBlockEndAlign(block);
+
+       /*check if material is being used by particles*/
+       for(psys=ob->particlesystem.first; psys; psys=psys->next)
+               if(psys->part->omat==ob->actcol)
+                       psys_mapto=1;
        
-       uiDefButF(block, NUMSLI, B_MATPRV, "DVar ",                     10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "The default value the texture uses to mix with (not RGB)");
-       
+       but = uiDefButF(block, NUMSLI, B_MATPRV, "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");
+       if(psys_mapto && mtex->pmapto & MAP_PA_INIT)
+               uiButSetFunc(but, particle_recalc_material, ma, NULL);
+
        /* MAP TO */
        uiBlockBeginAlign(block);
-       uiDefButBitS(block, TOG, MAP_COL, B_MATPRV, "Col",              10,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect basic color of the material");
-       uiDefButBitS(block, TOG3, MAP_NORM, B_MATPRV, "Nor",            50,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the rendered normal");
-       uiDefButBitS(block, TOG, MAP_COLSPEC, B_MATPRV, "Csp",          90,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the specularity color");
-       uiDefButBitS(block, TOG, MAP_COLMIR, B_MATPRV, "Cmir",          130,180,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the mirror color");
-       uiDefButBitS(block, TOG3, MAP_REF, B_MATPRV, "Ref",             180,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of the materials reflectivity");
-       uiDefButBitS(block, TOG3, MAP_SPEC, B_MATPRV, "Spec",           220,180,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of specularity");
-       uiDefButBitS(block, TOG3, MAP_AMB, B_MATPRV, "Amb",             270,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of ambient");
-       
-       uiDefButBitS(block, TOG3, MAP_HAR, B_MATPRV, "Hard",            10,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the hardness value");
-       uiDefButBitS(block, TOG3, MAP_RAYMIRR, B_MATPRV, "RayMir",      60,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the ray-mirror value");
-       uiDefButBitS(block, TOG3, MAP_ALPHA, B_MATPRV, "Alpha",         110,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the alpha value");
-       uiDefButBitS(block, TOG3, MAP_EMIT, B_MATPRV, "Emit",           160,160,45,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the emit value");
-       uiDefButBitS(block, TOG3, MAP_TRANSLU, B_MATPRV, "TransLu",             205,160,60,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the layer blending value");
-       if(from_nodes==0)
-               uiDefButBitS(block, TOG3, MAP_DISPLACE, B_MATPRV, "Disp",               265,160,45,19, &(mtex->mapto), 0, 0, 0, 0, "Let the texture displace the surface");
+
+       if(psys_mapto && pattr) {
+               but=uiDefButBitS(block, TOG3, MAP_PA_TIME, B_MAT_PARTICLE, "Time",      10,180,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the emission time of particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);                
+               but=uiDefButBitS(block, TOG3, MAP_PA_LIFE, B_MAT_PARTICLE, "Life",      70,180,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the life time of particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);                
+               but=uiDefButBitS(block, TOG3, MAP_PA_DENS, B_MAT_PARTICLE, "Dens",      130,180,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the density of particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);                
+               uiDefButBitS(block, TOG3, MAP_PA_IVEL, B_MAT_PARTICLE, "IVel",          190,180,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the initial velocity of particles");
+               uiDefButBitS(block, TOG3, MAP_PA_ROUGH, B_MAT_PARTICLE, "Rough",                250,180,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the roughness of child particles");
+
+               but=uiDefButBitS(block, TOG3, MAP_PA_SIZE, B_MAT_PARTICLE, "Size",      10,160,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the size of particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);
+               but=uiDefButBitS(block, TOG3, MAP_PA_KINK, B_MAT_PARTICLE, "Kink",      70,160,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the kink of child particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);
+               but=uiDefButBitS(block, TOG3, MAP_PA_LENGTH, B_MAT_PARTICLE, "Length",130,160,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the length of child particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);
+               but=uiDefButBitS(block, TOG3, MAP_PA_CLUMP, B_MAT_PARTICLE, "Clump",    190,160,60,19, &(mtex->pmapto), 0, 0, 0, 0, "Causes the texture to affect the clump of child particles");
+                       //uiButSetFunc(but, particle_recalc_material, ma, NULL);
+
+               uiBlockSetCol(block, TH_BUT_SETTING1);
+               uiDefButBitS(block, TOG, 1, B_MATPRV, "PAttr",          250,160,60,19, &pattr, 0, 0, 0, 0, "Display settings for particle attributes");
+               uiBlockSetCol(block, TH_AUTO);
+       }
+       else if (ma->material_type == MA_VOLUME) {
+               uiDefButBitS(block, TOG3, MAP_ALPHA, B_MATPRV, "Density",               10,180,60,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the alpha value");
+               uiDefButBitS(block, TOG3, MAP_EMIT, B_MATPRV, "Emit",           70,180,45,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the emit value");
+       }
+       else {
+               uiDefButBitS(block, TOG, MAP_COL, B_MATPRV, "Col",              10,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect basic color of the material");
+               uiDefButBitS(block, TOG3, MAP_NORM, B_MATPRV, "Nor",            50,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the rendered normal");
+               uiDefButBitS(block, TOG, MAP_COLSPEC, B_MATPRV, "Csp",          90,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the specularity color");
+               uiDefButBitS(block, TOG, MAP_COLMIR, B_MATPRV, "Cmir",          130,180,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the mirror color");
+               uiDefButBitS(block, TOG3, MAP_REF, B_MATPRV, "Ref",             180,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of the materials reflectivity");
+               uiDefButBitS(block, TOG3, MAP_SPEC, B_MATPRV, "Spec",           220,180,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of specularity");
+               uiDefButBitS(block, TOG3, MAP_AMB, B_MATPRV, "Amb",             270,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of ambient");
+               
+               if(psys_mapto) {
+                       uiDefButBitS(block, TOG3, MAP_HAR, B_MATPRV, "Hard",            10,160,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the hardness value");
+                       uiDefButBitS(block, TOG3, MAP_RAYMIRR, B_MATPRV, "RayMir",      50,160,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the ray-mirror value");
+                       uiDefButBitS(block, TOG3, MAP_ALPHA, B_MATPRV, "Alpha",         90,160,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the alpha value");
+                       uiDefButBitS(block, TOG3, MAP_EMIT, B_MATPRV, "Emit",           130,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the emit value");
+                       uiDefButBitS(block, TOG3, MAP_TRANSLU, B_MATPRV, "TransLu",             180,160,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the translucency value");
+                       if(from_nodes==0)
+                               uiDefButBitS(block, TOG3, MAP_DISPLACE, B_MATPRV, "Disp",               220,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Let the texture displace the surface");
+                       uiBlockSetCol(block, TH_BUT_SETTING1);
+                       uiDefButBitS(block, TOG, 1, B_MATPRV, "PAttr",          270,160,40,19, &pattr, 0, 0, 0, 0, "Display settings for particle attributes");
+                       uiBlockSetCol(block, TH_AUTO);
+               }
+               else {
+                       uiDefButBitS(block, TOG3, MAP_HAR, B_MATPRV, "Hard",            10,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the hardness value");
+                       uiDefButBitS(block, TOG3, MAP_RAYMIRR, B_MATPRV, "RayMir",      60,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the ray-mirror value");
+                       uiDefButBitS(block, TOG3, MAP_ALPHA, B_MATPRV, "Alpha",         110,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the alpha value");
+                       uiDefButBitS(block, TOG3, MAP_EMIT, B_MATPRV, "Emit",           160,160,45,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the emit value");
+                       uiDefButBitS(block, TOG3, MAP_TRANSLU, B_MATPRV, "TransLu",             205,160,60,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the translucency value");
+                       if(from_nodes==0)
+                               uiDefButBitS(block, TOG3, MAP_DISPLACE, B_MATPRV, "Disp",               265,160,45,19, &(mtex->mapto), 0, 0, 0, 0, "Let the texture displace the surface");
+               }
+       }
+
        uiBlockEndAlign(block);
-       
+
        uiBlockBeginAlign(block);
-       uiDefButS(block, MENU, B_MATPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
+       but=uiDefButS(block, MENU, B_MATPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
        uiBlockEndAlign(block);
+       if(psys_mapto && mtex->pmapto & MAP_PA_INIT)
+               uiButSetFunc(but, particle_recalc_material, ma, NULL);
 
        uiBlockBeginAlign(block);
        uiDefButF(block, NUMSLI, B_MATPRV, "Col ",                      155,100,155,19, &(mtex->colfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects color values");
        /* newnoise: increased range to 25, the constant offset for bumpmapping quite often needs a higher nor setting */
        uiDefButF(block, NUMSLI, B_MATPRV, "Nor ",                      155,80,155,19, &(mtex->norfac), 0.0, 25.0, 0, 0, "Sets the amount the texture affects normal values");
-       uiDefButF(block, NUMSLI, B_MATPRV, "Var ",                      155,60,155,19, &(mtex->varfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects other values");
+       but=uiDefButF(block, NUMSLI, B_MATPRV, "Var ",                  155,60,155,19, &(mtex->varfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects other values");
+       if(psys_mapto && mtex->pmapto & MAP_PA_INIT)
+               uiButSetFunc(but, particle_recalc_material, ma, NULL);
        uiDefButF(block, NUMSLI, B_MATPRV, "Disp ",                     155,40,155,19, &(mtex->dispfac), 0.0, 1.0, 0, 0, "Sets the amount the texture displaces the surface");
 
        uiBlockBeginAlign(block);
@@ -3186,30 +3503,43 @@ static void material_panel_map_input(Object *ob, Material *ma)
        
        /* TEXCO */
        uiBlockBeginAlign(block);
-       uiDefButS(block, ROW, B_MATPRV, "Glob",                 630,180,45,18, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Uses global coordinates for the texture coordinates");
-       uiDefButS(block, ROW, B_MATPRV, "Object",               675,180,75,18, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Uses linked object's coordinates for texture coordinates");
-       if(mtex->texco == TEXCO_UV) {
-               if(!verify_valid_uv_name(mtex->uvname))
-            uiBlockSetCol(block, TH_REDALERT);
-               but=uiDefBut(block, TEX, B_MATPRV, "UV:", 750,180,158,18, mtex->uvname, 0, 31, 0, 0, "Set name of UV layer to use, default is active UV layer");
-               uiButSetCompleteFunc(but, autocomplete_uv, NULL);
-               uiBlockSetCol(block, TH_AUTO);
-       }
-       else
-               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_MATPRV, "Ob:",750,180,158,18, &(mtex->object), "");
-       
-       uiDefButS(block, ROW, B_MATPRV, "UV",                   630,160,40,18, &(mtex->texco), 4.0, (float)TEXCO_UV, 0, 0, "Uses UV coordinates for texture coordinates");
-       uiDefButS(block, ROW, B_MATPRV, "Orco",                 670,160,55,18, &(mtex->texco), 4.0, (float)TEXCO_ORCO, 0, 0, "Uses the original undeformed coordinates of the object");
-       if( give_parteff(ob) )
-               uiDefButS(block, ROW, B_MATPRV, "Strand",       725,160,50,18, &(mtex->texco), 4.0, (float)TEXCO_STRAND, 0, 0, "Uses normalized strand texture coordinate (1D)");
-       else
-               uiDefButS(block, ROW, B_MATPRV, "Stick",        725,160,50,18, &(mtex->texco), 4.0, (float)TEXCO_STICKY, 0, 0, "Uses mesh's sticky coordinates for the texture coordinates");
-       uiDefButS(block, ROW, B_MATPRV, "Win",                  775,160,45,18, &(mtex->texco), 4.0, (float)TEXCO_WINDOW, 0, 0, "Uses screen coordinates as texture coordinates");
-       uiDefButS(block, ROW, B_MATPRV, "Nor",                  820,160,44,18, &(mtex->texco), 4.0, (float)TEXCO_NORM, 0, 0, "Uses normal vector as texture coordinates");
-       uiDefButS(block, ROW, B_MATPRV, "Refl",                 864,160,44,18, &(mtex->texco), 4.0, (float)TEXCO_REFL, 0, 0, "Uses reflection vector as texture coordinates");
        
-       uiDefButS(block, ROW, B_MATPRV, "Stress",               630,140,70,18, &(mtex->texco), 4.0, (float)TEXCO_STRESS, 0, 0, "Uses the difference of edge lengths compared to original coordinates of the mesh");
-       uiDefButS(block, ROW, B_MATPRV, "Tangent",              700,140,70,18, &(mtex->texco), 4.0, (float)TEXCO_TANGENT, 0, 0, "Uses the optional tangent vector as texture coordinates");
+       if (ma->material_type == MA_VOLUME) {
+               uiDefButS(block, ROW, B_MATPRV, "Glob",                 630,180,45,18, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Uses global coordinates for the texture coordinates");
+               uiDefButS(block, ROW, B_MATPRV, "Object",               675,180,75,18, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Uses linked object's coordinates for texture coordinates");
+               uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_MATPRV, "Ob:",750,180,158,18, &(mtex->object), "");
+       } else {
+               uiDefButS(block, ROW, B_MATPRV, "Glob",                 630,180,45,18, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Uses global coordinates for the texture coordinates");
+               uiDefButS(block, ROW, B_MATPRV, "Object",               675,180,75,18, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Uses linked object's coordinates for texture coordinates");
+               if(mtex->texco == TEXCO_UV && !(mtex->texflag & MTEX_DUPLI_MAPTO)) {
+                       if(!verify_valid_uv_name(mtex->uvname))
+                               uiBlockSetCol(block, TH_REDALERT);
+                       but=uiDefBut(block, TEX, B_MATPRV, "UV:", 750,180,158,18, mtex->uvname, 0, 31, 0, 0, "Set name of UV layer to use, default is active UV layer");
+                       uiButSetCompleteFunc(but, autocomplete_uv, NULL);
+                       uiBlockSetCol(block, TH_AUTO);
+               }
+               else
+                       uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_MATPRV, "Ob:",750,180,158,18, &(mtex->object), "");
+               
+               uiDefButS(block, ROW, B_MATPRV, "UV",                   630,160,40,18, &(mtex->texco), 4.0, (float)TEXCO_UV, 0, 0, "Uses UV coordinates for texture coordinates");
+               uiDefButS(block, ROW, B_MATPRV, "Orco",                 670,160,55,18, &(mtex->texco), 4.0, (float)TEXCO_ORCO, 0, 0, "Uses the original undeformed coordinates of the object");
+               if( ob->particlesystem.first )
+                       uiDefButS(block, ROW, B_MATPRV, "Strand",       725,160,50,18, &(mtex->texco), 4.0, (float)TEXCO_STRAND, 0, 0, "Uses normalized strand texture coordinate (1D)");
+               else
+                       uiDefButS(block, ROW, B_MATPRV, "Stick",        725,160,50,18, &(mtex->texco), 4.0, (float)TEXCO_STICKY, 0, 0, "Uses mesh's sticky coordinates for the texture coordinates");
+               uiDefButS(block, ROW, B_MATPRV, "Win",                  775,160,45,18, &(mtex->texco), 4.0, (float)TEXCO_WINDOW, 0, 0, "Uses screen coordinates as texture coordinates");
+               uiDefButS(block, ROW, B_MATPRV, "Nor",                  820,160,44,18, &(mtex->texco), 4.0, (float)TEXCO_NORM, 0, 0, "Uses normal vector as texture coordinates");
+               uiDefButS(block, ROW, B_MATPRV, "Refl",                 864,160,44,18, &(mtex->texco), 4.0, (float)TEXCO_REFL, 0, 0, "Uses reflection vector as texture coordinates");
+               
+               uiDefButS(block, ROW, B_MATPRV, "Stress",               630,140,70,18, &(mtex->texco), 4.0, (float)TEXCO_STRESS, 0, 0, "Uses the difference of edge lengths compared to original coordinates of the mesh");
+               uiDefButS(block, ROW, B_MATPRV, "Tangent",              700,140,70,18, &(mtex->texco), 4.0, (float)TEXCO_TANGENT, 0, 0, "Uses the optional tangent vector as texture coordinates");
+               uiBlockEndAlign(block);
+
+               if(ELEM(mtex->texco, TEXCO_UV, TEXCO_ORCO))
+                       uiDefButBitS(block, TOG, MTEX_DUPLI_MAPTO, B_MATPRV, "From Dupli",      820,140,88,18, &(mtex->texflag), 0, 0, 0, 0, "Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent");
+               else if(mtex->texco == TEXCO_OBJECT)
+                       uiDefButBitS(block, TOG, MTEX_OB_DUPLI_ORIG, B_MATPRV, "From Original", 820,140,88,18, &(mtex->texflag), 0, 0, 0, 0, "Dupli's derive their object coordinates from the original objects transformation");
+       }
 
        /* COORDS */
        uiBlockBeginAlign(block);
@@ -3244,24 +3574,32 @@ static void material_panel_map_input(Object *ob, Material *ma)
 }
 
 
-static void material_panel_texture(Material *ma)
+static void material_panel_texture(Object *ob, Material *ma)
 {
        uiBlock *block;
+       uiBut *but;
        MTex *mtex;
        ID *id;
-       int loos;
-       int a;
+       ParticleSystem *psys;
+       int loos, psys_mapto=0;
+       int a, num_mtex;
        char str[64], *strp;
        
        block= uiNewBlock(&curarea->uiblocks, "material_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
        if(uiNewPanel(curarea, block, "Texture", "Material", 960, 0, 318, 204)==0) return;
        uiClearButLock();
        
+       /*check if material is being used by particles*/
+       for(psys=ob->particlesystem.first; psys; psys=psys->next)
+               if(psys->part->omat==ob->actcol)
+                       psys_mapto=1;
+
        /* TEX CHANNELS */
        uiBlockSetCol(block, TH_BUT_NEUTRAL);
        
        uiBlockBeginAlign(block);
-       for(a= 0; a<MAX_MTEX; a++) {
+       num_mtex= texture_channels_num_display(ma->mtex);
+       for(a= 0; a<num_mtex; a++) {
                mtex= ma->mtex[a];
                if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
                else strcpy(str, "");
@@ -3275,15 +3613,21 @@ static void material_panel_texture(Material *ma)
        /* SEPTEX */
        uiBlockSetCol(block, TH_AUTO);
        
-       for(a= 0; a<MAX_MTEX; a++) {
+       for(a= 0; a<num_mtex; a++) {
                mtex= ma->mtex[a];
                if(mtex && mtex->tex) {
-                       uiDefIconButBitS(block, ICONTOGN, 1<<a, B_MATPRV, ICON_CHECKBOX_HLT-1,  -20, 180-18*a, 28, 20, &ma->septex, 0.0, 0.0, 0, 0, "Click to disable or enable this texture channel");
+                       but=uiDefIconButBitI(block, ICONTOGN, 1<<a, B_MATPRV, ICON_CHECKBOX_HLT-1,      -20, 180-18*a, 28, 20, &ma->septex, 0.0, 0.0, 0, 0, "Click to disable or enable this texture channel");
+
+                       if(psys_mapto && ma->mtex[a]->mapto & MAP_PA_IVEL)
+                               uiButSetFunc(but, particle_recalc_material, ma, NULL);
                }
        }
+       /* copy/paste/up/down */
        uiBlockBeginAlign(block);
-       uiDefIconBut(block, BUT, B_MTEXCOPY, ICON_COPYUP,       100,180,23,21, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
-       uiDefIconBut(block, BUT, B_MTEXPASTE, ICON_PASTEUP,     125,180,23,21, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
+       uiDefIconBut(block, BUT, B_MTEXCOPY, ICON_COPYUP,       100,180,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
+       uiDefIconBut(block, BUT, B_MTEXPASTE, ICON_PASTEUP,     125,180,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
+       uiDefIconBut(block, BUT, B_MTEXMOVEUP, VICON_MOVE_UP,   150,180,25,19, 0, 0, 0, 0, 0, "Move texture channel up");
+       uiDefIconBut(block, BUT, B_MTEXMOVEDOWN, VICON_MOVE_DOWN, 175,180,25,19, 0, 0, 0, 0, 0, "Move texture channel down");
        uiBlockEndAlign(block);
        uiBlockSetCol(block, TH_AUTO);
        
@@ -3370,7 +3714,7 @@ static void material_panel_tramir(Material *ma)
        yco -= YSPACE;
        uiBlockBeginAlign(block);
        uiDefButF(block, NUM, B_MATPRV, "Max Dist:",
-               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->dist_mir), 0.0, 100.0, 100, 0, "Maximum distance of reflected rays. Reflections further than this range fade to sky color");
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->dist_mir), 0.0, 10000.0, 100, 0, "Maximum distance of reflected rays. Reflections further than this range fade to sky color");
        uiDefButS(block, MENU, B_MATPRV, "Ray end fade-out: %t|Fade to Sky Color %x0|Fade to Material Color %x1",
                X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->fadeto_mir), 0, 0, 0, 0, "The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor.");
        uiBlockEndAlign(block);
@@ -3386,7 +3730,7 @@ static void material_panel_tramir(Material *ma)
        uiDefButF(block, NUMSLI, B_MATPRV, "IOR: ",
                X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->ang), 1.0, 3.0, 100, 2, "Sets angular index of refraction for raytraced refraction");
        uiDefButF(block, NUMSLI, B_MATPRV, "Fresnel: ",
-               X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->fresnel_tra), 0.0, 5.0, 10, 2, "Power of Fresnel for mirror reflection");
+               X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->fresnel_tra), 0.0, 5.0, 10, 2, "Power of Fresnel for transparency (Ray or ZTransp)");
        uiDefButF(block, NUMSLI, B_MATPRV, "Fac: ",
                X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->fresnel_tra_i), 1.0, 5.0, 10, 2, "Blending factor for Fresnel");
        uiBlockEndAlign(block);
@@ -3395,7 +3739,7 @@ static void material_panel_tramir(Material *ma)
        
        uiBlockBeginAlign(block);
        uiDefButF(block, NUMSLI, B_MATPRV, "Gloss: ",
-               X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->gloss_tra), 0.0, 1.0, 100, 0, "The clarity of the refraction. Values < 1.0 give diffuse, blurry reflections ");
+               X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->gloss_tra), 0.0, 1.0, 100, 0, "The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions");
        uiDefButS(block, NUM, B_MATPRV, "Samples:",
                X2CLM2, yco-=BUTH, BUTW2, BUTH, &(ma->samp_gloss_tra), 0.0, 1024.0, 100, 0, "Number of cone samples averaged for blurry refractions");  
        uiDefButF(block, NUM, B_MATPRV, "Thresh: ",
@@ -3585,7 +3929,7 @@ static void material_panel_shading(Material *ma)
        uiBlock *block;
        
        block= uiNewBlock(&curarea->uiblocks, "material_panel_shading", UI_EMBOSS, UI_HELV, curarea->win);
-       if(uiNewPanel(curarea, block, "Shaders", "Material", 640, 0, 318, 204)==0) return;
+       if(uiNewPanel(curarea, block, "Shaders", "Material", 640, 0, 318, 224)==0) return;
        
        uiSetButLock(ma->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
        
@@ -3608,14 +3952,15 @@ static void material_panel_shading(Material *ma)
                uiBlockSetCol(block, TH_BUT_SETTING1);
                
                uiBlockBeginAlign(block);
-               uiDefButBitI(block, TOG, MA_HALO_FLARE, B_MATPRV, "Flare",245,142,65,28, &(ma->mode), 0, 0, 0, 0, "Renders halo as a lensflare");
-               uiDefButBitI(block, TOG, MA_HALO_RINGS, B_MATPRV, "Rings",              245,123,65, 18, &(ma->mode), 0, 0, 0, 0, "Renders rings over halo");
-               uiDefButBitI(block, TOG, MA_HALO_LINES, B_MATPRV, "Lines",              245,104,65, 18, &(ma->mode), 0, 0, 0, 0, "Renders star shaped lines over halo");
-               uiDefButBitI(block, TOG, MA_STAR, B_MATPRV, "Star",             245,85,65, 18, &(ma->mode), 0, 0, 0, 0, "Renders halo as a star");
-               uiDefButBitI(block, TOG, MA_HALOTEX, B_MATPRV, "HaloTex",       245,66,65, 18, &(ma->mode), 0, 0, 0, 0, "Gives halo a texture");
-               uiDefButBitI(block, TOG, MA_HALOPUNO, B_MATPRV, "HaloPuno",     245,47,65, 18, &(ma->mode), 0, 0, 0, 0, "Uses the vertex normal to specify the dimension of the halo");
-               uiDefButBitI(block, TOG, MA_HALO_XALPHA, B_MATPRV, "X Alpha",   245,28,65, 18, &(ma->mode), 0, 0, 0, 0, "Uses extreme alpha");
-               uiDefButBitI(block, TOG, MA_HALO_SHADE, B_MATPRV, "Shaded",     245,9,65, 18, &(ma->mode), 0, 0, 0, 0, "Lets halo receive light and shadows");
+               uiDefButBitI(block, TOG, MA_HALO_FLARE,  B_MATPRV, "Flare",    245,161,65,28, &(ma->mode), 0, 0, 0, 0, "Renders halo as a lensflare");
+               uiDefButBitI(block, TOG, MA_HALO_RINGS,  B_MATPRV, "Rings",        245,142,65,18, &(ma->mode), 0, 0, 0, 0, "Renders rings over halo");
+               uiDefButBitI(block, TOG, MA_HALO_LINES,  B_MATPRV, "Lines",        245,123,65,18, &(ma->mode), 0, 0, 0, 0, "Renders star shaped lines over halo");
+               uiDefButBitI(block, TOG, MA_STAR,        B_MATPRV, "Star",         245,104,65, 18, &(ma->mode), 0, 0, 0, 0, "Renders halo as a star");
+               uiDefButBitI(block, TOG, MA_HALOTEX,     B_MATPRV, "HaloTex",  245,85,65, 18, &(ma->mode), 0, 0, 0, 0, "Gives halo a texture");
+               uiDefButBitI(block, TOG, MA_HALOPUNO,    B_MATPRV, "HaloPuno", 245,66,65, 18, &(ma->mode), 0, 0, 0, 0, "Uses the vertex normal to specify the dimension of the halo");
+               uiDefButBitI(block, TOG, MA_HALO_XALPHA, B_MATPRV, "X Alpha",  245,47,65, 18, &(ma->mode), 0, 0, 0, 0, "Uses extreme alpha");
+               uiDefButBitI(block, TOG, MA_HALO_SHADE,  B_MATPRV, "Shaded",   245,28,65,  18, &(ma->mode), 0, 0, 0, 0, "Lets halo receive light and shadows");
+               uiDefButBitI(block, TOG, MA_HALO_SOFT,   B_MATPRV, "Soft",         245,9,65,  18, &(ma->mode), 0, 0, 0, 0, "Softens the halo");
                uiBlockEndAlign(block);
        }
        else {
@@ -3663,23 +4008,24 @@ static void material_panel_shading(Material *ma)
                uiDefButF(block, NUMSLI, B_MATPRV, "SBias ",    159,30,151,19, &(ma->sbias), 0.0, 0.25, 10, 2, "Shadow bias, to prevent terminator problems on shadow boundary");
                uiDefButF(block, NUMSLI, B_MATPRV, "Amb ",              9,10,150,19, &(ma->amb), 0.0, 1.0, 0, 0, "Sets the amount of global ambient color the material receives");
                uiDefButF(block, NUMSLI, B_MATPRV, "Emit ",             159,10,151,19, &(ma->emit), 0.0, 2.0, 0, 0, "Sets the amount of light the material emits");
+               uiDefButF(block, NUMSLI, B_MATPRV, "LBias ",    9,-10,300,19, &(ma->lbias), 0.0, 10.0, 100, 2, "Factor to multiply shadowbuffer bias with (0 is ignore)");
                uiBlockEndAlign(block);
 
                uiBlockSetCol(block, TH_BUT_SETTING1);
                uiDefButBitI(block, TOG, MA_TANGENT_V, B_MATPRV, "Tangent V",   245,180,65,19, &(ma->mode), 0, 0, 0, 0, "Use the tangent vector in V direction for shading");
                
-               /* qdn: normalmap tangents separated from shading */
-               uiDefButBitI(block, TOG, MA_NORMAP_TANG, B_MATPRV, "NMap TS",   245,160,65,19, &(ma->mode), 0, 0, 0, 0, "Enable Tangent Space normal mapping");
-
                uiBlockBeginAlign(block);
                uiDefButBitI(block, TOG, MA_SHADOW, B_MATPRV,   "Shadow",                       245,140,65,19, &(ma->mode), 0, 0, 0, 0, "Makes material receive shadows");
                uiDefButBitI(block, TOG, MA_SHADOW_TRA, B_MATPRV, "TraShadow",          245,120,65,19, &(ma->mode), 0, 0, 0, 0, "Receives transparent shadows based at material color and alpha");
                uiDefButBitI(block, TOG, MA_ONLYSHADOW, B_MATPRV,       "OnlyShad",             245,100,65,20, &(ma->mode), 0, 0, 0, 0, "Renders shadows on material as Alpha value");
-               uiDefButBitI(block, TOG, MA_RAYBIAS, B_MATPRV, "Bias",                          245,80,65,19, &(ma->mode), 0, 0, 0, 0, "Prevents ray traced shadow errors with phong interpolated normals (terminator problem)");
+               uiDefButBitS(block, TOG, MA_CUBIC, B_MATPRV, "Cubic",                           245,80,65,19, &(ma->shade_flag), 0, 0, 0, 0, "Use Cubic interpolation of diffuse values, for smoother transitions");
+               uiDefButBitI(block, TOG, MA_RAYBIAS, B_MATPRV, "Bias",                          245,60,65,19, &(ma->mode), 0, 0, 0, 0, "Prevents ray traced shadow errors with phong interpolated normals (terminator problem)");
 
                uiBlockBeginAlign(block);
                uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_MATPRV, "GR:",       9, 55, 150, 19, &ma->group, "Limit Lighting to Lamps in this Group"); 
-               uiDefButBitI(block, TOG, MA_GROUP_NOLAY, B_MATPRV,      "Exclusive",    159,55, 85,20, &(ma->mode), 0, 0, 0, 0, "The material exclusively uses Lamps in this Group");
+               uiDefButBitI(block, TOG, MA_GROUP_NOLAY, B_MATPRV,      "Exclusive",    159,55, 85,20, &(ma->mode), 0, 0, 0, 0, "Material uses Lights in this group exclusively, they get excluded from the Scene lighting");
+               
+               
        }
 }
 
@@ -3694,14 +4040,14 @@ static void material_panel_ramps(Material *ma)
        uiNewPanelTabbed("Material", "Material");
        if(uiNewPanel(curarea, block, "Ramps", "Material", 640, 0, 318, 204)==0) return;
        
-       uiSetButLock(ma->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
-       
        uiBlockBeginAlign(block);
        uiBlockSetCol(block, TH_BUT_SETTING1);
        uiDefButS(block, ROW, B_REDR, "Show Col Ramp",10,180,150,20, &ma->ramp_show, 0, 0, 0, 0, "Show ramp buttons for material diffuse color");
        uiDefButS(block, ROW, B_REDR, "Show Spec Ramp",160,180,150,20, &ma->ramp_show, 0, 1, 0, 0, "Show ramp buttons for material specular color");
        uiBlockSetCol(block, TH_AUTO);
        
+       uiSetButLock(ma->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
+       
        /* COLORBAND */
        uiBlockBeginAlign(block);
        uiDefButBitI(block, TOG, ma->ramp_show?MA_RAMP_SPEC:MA_RAMP_COL, B_MATCOLORBAND, "Colorband",10,145,80,20, &ma->mode, 0, 0, 0, 0, "Toggles colorband ramp operations");
@@ -3736,18 +4082,38 @@ static uiBlock *strand_menu(void *mat_v)
 {
        Material *ma= mat_v;
        uiBlock *block;
-       
+       int buth=20, butw=230, butx=10, buty=180;
+
        block= uiNewBlock(&curarea->uiblocks, "strand menu", UI_EMBOSS, UI_HELV, curarea->win);
-       
+        
+       if(ma->mode & MA_STR_B_UNITS)
+               buty += buth;
+
        /* use this for a fake extra empy space around the buttons */
-       uiDefBut(block, LABEL, 0, "", 0, 0, 250, 100, NULL,  0, 0, 0, 0, "");
-       
+       uiDefBut(block, LABEL, 0, "", 0, 0, butw+20, buty+10, NULL,  0, 0, 0, 0, "");
+                                       /* event return 0, to prevent menu to close */
+       
+       uiBlockBeginAlign(block);
+       uiDefButBitI(block, TOG, MA_TANGENT_STR, 0,     "Use Tangent Shading",  butx,buty-=buth,butw,buth, &(ma->mode), 0, 0, 0, 0, "Uses direction of strands as normal for tangent-shading");
+       uiDefButBitI(block, TOG, MA_STR_SURFDIFF, 0, "Surface Diffuse", butx,buty-=buth,butw/2,buth, &(ma->mode), 0, 0, 0, 0, "Make diffuse shading more similar to shading the surface");
+       uiDefButF(block, NUM, 0, "Dist", butx+butw/2,buty,butw/2,buth, &ma->strand_surfnor, 0.0f, 10.0f, 2, 0, "Distance in Blender units over which to blend in the surface normal");
+
+       buty -= 5;
        uiBlockBeginAlign(block);
-                                       /* event return 0, to prevent menu to close */
-       uiDefButBitI(block, TOG, MA_TANGENT_STR, 0,     "Use Tangent Shading",  10,70,230,20, &(ma->mode), 0, 0, 0, 0, "Uses direction of strands as normal for tangent-shading");
-       uiDefButF(block, NUMSLI, 0, "Start ",   10, 50, 230,20,   &ma->strand_sta, 0.25, 20.0, 2, 0, "Start size of strands in pixels");
-       uiDefButF(block, NUMSLI, 0, "End ",             10, 30, 230,20,  &ma->strand_end, 0.25, 10.0, 2, 0, "End size of strands in pixels");
-       uiDefButF(block, NUMSLI, 0, "Shape ",   10, 10, 230,20,  &ma->strand_ease, -0.9, 0.9, 2, 0, "Shape of strands, positive value makes it rounder, negative makes it spiky");
+       uiDefButBitI(block, TOG, MA_STR_B_UNITS, 0,     "Use Blender Units", butx,buty-=buth,butw,buth, &(ma->mode), 0, 0, 0, 0, "Use actual Blender units for widths instead of pixels");
+       if(ma->mode & MA_STR_B_UNITS){
+               uiDefButF(block, NUMSLI, 0, "Start ",   butx,buty-=buth, butw,buth,   &ma->strand_sta, 0.0001, 2.0, 2, 0, "Start size of strands in Blender units");
+               uiDefButF(block, NUMSLI, 0, "End ",             butx,buty-=buth, butw,buth,  &ma->strand_end, 0.0001, 1.0, 2, 0, "End size of strands in Blender units");
+               uiDefButF(block, NUMSLI, 0, "Minimum ",         butx,buty-=buth, butw,buth,  &ma->strand_min, 0.001, 10.0, 0, 0, "Minimum size of strands in pixels");
+       }
+       else{
+               uiDefButF(block, NUMSLI, 0, "Start ",   butx,buty-=buth, butw,buth,   &ma->strand_sta, 0.25, 20.0, 2, 0, "Start size of strands in pixels");
+               uiDefButF(block, NUMSLI, 0, "End ",             butx,buty-=buth, butw,buth,  &ma->strand_end, 0.25, 10.0, 2, 0, "End size of strands in pixels");
+       }
+       uiDefButF(block, NUMSLI, 0, "Shape ",   butx,buty-=buth, butw,buth,  &ma->strand_ease, -0.9, 0.9, 2, 0, "Shape of strands, positive value makes it rounder, negative makes it spiky");
+       uiDefButF(block, NUMSLI, 0, "Width Fade ",      butx,buty-=buth, butw,buth,  &ma->strand_widthfade, 0.0, 2.0, 2, 0, "Transparency along the width of the strand");
+       uiDefBut(block, TEX, B_MATPRV, "UV:", butx,buty-=buth,butw,buth, ma->strand_uvname, 0, 31, 0, 0, "Set name of UV layer to override");
 
        uiBlockSetDirection(block, UI_TOP);
        BIF_preview_changed(ID_MA);
@@ -3755,7 +4121,7 @@ static uiBlock *strand_menu(void *mat_v)
 }
 
 
-static void material_panel_material(Material *ma)
+static void material_panel_material_solid(Material *ma)
 {
        uiBlock *block;
        float *colpoin = NULL;
@@ -3785,13 +4151,14 @@ static void material_panel_material(Material *ma)
                        uiBlockSetCol(block, TH_BUT_SETTING1);
                        uiDefButBitI(block, TOG, MA_VERTEXCOL, B_MAT_VCOL_LIGHT,        "VCol Light",   8,166,74,20, &(ma->mode), 0, 0, 0, 0, "Adds vertex colors as extra light");
                        uiDefButBitI(block, TOG, MA_VERTEXCOLP, B_MAT_VCOL_PAINT, "VCol Paint", 82,166,74,20, &(ma->mode), 0, 0, 0, 0, "Replaces material's colors with vertex colors");
-                       uiDefButBitI(block, TOG, MA_FACETEXTURE, B_REDR, "TexFace",             156,166,64,20, &(ma->mode), 0, 0, 0, 0, "Sets UV-Editor assigned texture as color and texture info for faces");
-                       if (ma->mode & MA_FACETEXTURE) uiDefButBitI(block, TOG, MA_FACETEXTURE_ALPHA, B_REDR, "A",              220,166,20,20, &(ma->mode), 0, 0, 0, 0, "Use alpha channel in 'TexFace' assigned images");
-                       uiDefButBitI(block, TOG, MA_SHLESS, B_MATPRV, "Shadeless",      240,166,63,20, &(ma->mode), 0, 0, 0, 0, "Makes material insensitive to light or shadow");
+                       uiDefButBitI(block, TOG, MA_FACETEXTURE, B_MATPRV, "TexFace",           156,166,60,20, &(ma->mode), 0, 0, 0, 0, "Sets UV-Editor assigned texture as color and texture info for faces");
+                       uiDefButBitI(block, TOG, MA_FACETEXTURE_ALPHA, B_MATPRV, "A",           216,166,20,20, &(ma->mode), 0, 0, 0, 0, "Use alpha channel in 'TexFace' assigned images");
+                       uiDefButBitI(block, TOG, MA_SHLESS, B_MATPRV, "Shadeless",      236,166,67,20, &(ma->mode), 0, 0, 0, 0, "Makes material insensitive to light or shadow");
                        
-                       uiDefButBitI(block, TOG, MA_NOMIST, B_NOP,      "No Mist",              8,146,74,20, &(ma->mode), 0, 0, 0, 0, "Sets the material to ignore mist values");
+                       uiDefButBitI(block, TOG, MA_NOMIST, B_MATPRV,   "No Mist",              8,146,74,20, &(ma->mode), 0, 0, 0, 0, "Sets the material to ignore mist values");
                        uiDefButBitI(block, TOG, MA_ENV, B_MATPRV,      "Env",                  82,146,74,20, &(ma->mode), 0, 0, 0, 0, "Causes faces to render with alpha zero: allows sky/backdrop to show through (only for solid faces)");
-                       uiDefButF(block, NUM, B_NOP, "Shad A ",                                 156,146,147,19, &ma->shad_alpha, 0.001, 1.0f, 100, 0, "Shadow casting alpha, only in use for Irregular Shadowbuffer");
+                       uiDefButBitS(block, TOG, MA_OBCOLOR, B_MATPRV, "ObColor",               156,146,60,20, &(ma->shade_flag), 0, 0, 0, 0, "Modulate the result with a per object color");
+                       uiDefButF(block, NUM, B_NOP, "Shad A ",                                 216,146,87,20, &ma->shad_alpha, 0.001, 1.0f, 10, 2, "Shadow casting alpha, only in use for Irregular Shadowbuffer");
                }
                uiBlockSetCol(block, TH_AUTO);
                uiBlockBeginAlign(block);
@@ -3842,6 +4209,43 @@ static void material_panel_material(Material *ma)
 
 }
 
+static void material_panel_material_volume(Material *ma)
+{
+       uiBlock *block;
+       short yco=PANEL_YMAX;
+       
+       block= uiNewBlock(&curarea->uiblocks, "material_panel_material_volume", UI_EMBOSS, UI_HELV, curarea->win);
+       if(uiNewPanel(curarea, block, "Volume", "Material", PANELX, PANELY, PANELW, PANELH)==0) return;
+       
+       uiSetButLock(ma->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
+       
+       uiBlockBeginAlign(block);
+       uiDefButF(block, NUM, B_MATPRV, "Step Size: ",
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->vol_stepsize), 0.001, 100.0, 10, 2, "Ray marching step size");
+       uiDefButF(block, NUMSLI, B_MATPRV, "Density: ",
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->alpha), 0.0, 1.0, 0, 0, "Base opacity value");
+       uiDefButF(block, NUM, B_MATPRV, "Absorption: ",
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->vol_absorption), 0.0, 5.0, 0, 0, "Multiplier for absorption");
+       uiBlockEndAlign(block);
+       
+       yco -= YSPACE;
+       
+       uiDefButF(block, NUMSLI, B_MATPRV, "Emit: ",
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->emit), 0.0, 2.0, 0, 0, "Emission component");
+       
+       yco -= YSPACE;
+               
+       uiBlockBeginAlign(block);
+       uiDefButBitS(block, TOG, MA_VOL_ATTENUATED, B_MATPRV, "Shading",
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->vol_shadeflag), 0, 0, 0, 0, "Uses absorption for light attenuation");
+       uiDefButF(block, NUM, B_MATPRV, "Step Size: ",
+               X2CLM1, yco-=BUTH, BUTW2, BUTH, &(ma->vol_shade_stepsize), 0.001, 100.0, 10, 2, "Step");
+       uiBlockEndAlign(block);
+
+       uiDefBut(block, LABEL, B_DIFF, "",
+               X2CLM2, yco, BUTW2, BUTH, 0, 0, 0, 0, 0, "");
+}
+
 static void material_panel_nodes(Material *ma)
 {
        bNode *node;
@@ -3880,7 +4284,7 @@ static void material_panel_links(Object *ob, Material *ma)
        
        block= uiNewBlock(&curarea->uiblocks, "material_panel_links", UI_EMBOSS, UI_HELV, curarea->win);
        /* 310 makes sorting code to put it right after preview panel */
-       if(uiNewPanel(curarea, block, "Links and Pipeline", "Material", 310, 0, 318, 204)==0) return;
+       if(uiNewPanel(curarea, block, "Links and Pipeline", "Material", 310, 0, 338, 204)==0) return;
 
        /* Links from object to material/nodes */
        uiDefBut(block, ROUNDBOX, 0, "",                                        5, 90, 310, 110, NULL, 7.0, 0.0, 15 , 20, ""); 
@@ -3895,7 +4299,7 @@ static void material_panel_links(Object *ob, Material *ma)
        if(ma) uiSetButLock(ma->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
        
        if(ma)
-               uiDefButC(block, TOG, B_MAT_USENODES, "Nodes", xco+5,160,300-xco-5,20, &ma->use_nodes, 0.0f, 0.0f, 0, 0, "");
+               uiDefButC(block, TOG, B_MAT_USENODES, "Nodes", xco+5,160,300-xco-5,20, &ma->use_nodes, 0.0f, 0.0f, 0, 0, "Enables as a Nodes Material");
                                  
        if(ob->actcol==0) ob->actcol= 1;        /* because of TOG|BIT button */
        
@@ -3919,6 +4323,7 @@ static void material_panel_links(Object *ob, Material *ma)
        }
        
        uiBlockSetCol(block, TH_BUT_ACTION);
+       uiClearButLock();
        uiDefButBitS(block, TOG, 1<<(ob->actcol-1), B_MATFROM, "OB",    125,135,32,20, &ob->colbits, 0, 0, 0, 0, "Links material to object");
        idn= ob->data;
        strncpy(str, idn->name, 2);
@@ -3972,7 +4377,10 @@ static void material_panel_links(Object *ob, Material *ma)
        uiDefButBitI(block, TOG, MA_ONLYCAST, B_MATPRV,"OnlyCast",              85,10,75,19, &(ma->mode), 0, 0, 0, 0, "Makes faces cast shadows only, not rendered");
        uiDefButBitI(block, TOG, MA_TRACEBLE, B_NOP,"Traceable",        160,10,75,19, &(ma->mode), 0, 0, 0, 0, "Makes material detectable by ray tracing");
        uiDefButBitI(block, TOG, MA_SHADBUF, B_MATPRV,  "Shadbuf",              235,10,75,19, &(ma->mode), 0, 0, 0, 0, "Makes material cast shadows from shadow buffer lamps");
-                                 
+       uiBlockEndAlign(block);
+       
+       uiDefButS(block, MENU, B_MATPRV, "Material Type %t|Solid %x0|Halo %x1|Volume %x2",
+               10, -15, 300, 20, &(ma->material_type), 0.0, 0.0, 0, 0, "");
        
 }
 
@@ -4030,27 +4438,32 @@ void material_panels()
                
                ma= editnode_get_active_material(ma);
                if(ma) {
-                       material_panel_material(ma);
-                       material_panel_ramps(ma);
-                       material_panel_shading(ma);
-                       
-                       if (G.scene->r.renderer==R_INTERN)
-                               material_panel_tramir(ma);
-                       else {
-                               if(ma->YF_ar==0.f) {
-                                       ma->YF_ar = ma->YF_ag = ma->YF_ab = 1;
-                                       ma->YF_dscale = 1;
+                       if (ma->material_type == MA_SOLID) {
+                               material_panel_material_solid(ma);
+                               material_panel_ramps(ma);
+                               material_panel_shading(ma);
+                               
+                               if (G.scene->r.renderer==R_INTERN)
+                                       material_panel_tramir(ma);
+                               else {
+                                       if(ma->YF_ar==0.f) {
+                                               ma->YF_ar = ma->YF_ag = ma->YF_ab = 1;
+                                               ma->YF_dscale = 1;
+                                       }
+                                       material_panel_tramir_yafray(ma);
                                }
-                               material_panel_tramir_yafray(ma);
-                       }
 
-                       material_panel_sss(ma);
-                       material_panel_texture(ma);
+                               material_panel_sss(ma);
+                               
+                       } else if (ma->material_type == MA_VOLUME) {
+                               material_panel_material_volume(ma);
+                       }
+                       material_panel_texture(ob, ma);
                        
                        mtex= ma->mtex[ ma->texact ];
                        if(mtex && mtex->tex) {
                                material_panel_map_input(ob, ma);
-                               material_panel_map_to(ma, from_nodes);
+                               material_panel_map_to(ob, ma, from_nodes);
                        }
                }
        }
@@ -4083,6 +4496,11 @@ void lamp_panels()
                /* spherelight radius default is zero, so nothing to do */
                lamp_panel_yafray(ob, la);
        }
+       
+       if(la->type == LA_SUN){
+               lamp_panel_atmosphere(ob, ob->data);
+       }
+
        lamp_panel_texture(ob, ob->data);
        lamp_panel_mapto(ob, ob->data);
 
@@ -4170,7 +4588,7 @@ void texture_panels()
                        switch(tex->type) {
                        case TEX_IMAGE:
                                texture_panel_image(&tex->ima, &tex->iuser);
-                               texture_panel_image_map(tex);
+                               texture_panel_image_map(tex, mtex);
                                break;
                        case TEX_ENVMAP:
                                texture_panel_envmap(tex);