render_preview.c

Go to the documentation of this file.

/* 
 * $Id: render_preview.c 38375 2011-07-13 19:27:42Z campbellbarton $
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) Blender Foundation.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

/* global includes */

#include <stdlib.h>
#include <math.h>
#include <string.h>

#ifndef WIN32
#include <unistd.h>
#else
#include <io.h>
#endif   
#include "MEM_guardedalloc.h"

#include "BLO_readfile.h" 

#include "BLI_math.h"
#include "BLI_blenlib.h"
#include "BLI_threads.h"
#include "BLI_utildefines.h"

#include "DNA_world_types.h"
#include "DNA_camera_types.h"
#include "DNA_material_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_lamp_types.h"
#include "DNA_space_types.h"
#include "DNA_view3d_types.h"
#include "DNA_scene_types.h"
#include "DNA_brush_types.h"
#include "DNA_screen_types.h"

#include "BKE_context.h"
#include "BKE_depsgraph.h"
#include "BKE_global.h"
#include "BKE_idprop.h"
#include "BKE_image.h"
#include "BKE_icons.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BKE_material.h"
#include "BKE_node.h"
#include "BKE_object.h"
#include "BKE_texture.h"
#include "BKE_world.h"

#include "IMB_imbuf.h"
#include "IMB_imbuf_types.h"

#include "BIF_gl.h"
#include "BIF_glutil.h"

#include "PIL_time.h"

#include "RE_pipeline.h"


#include "WM_api.h"
#include "WM_types.h"

#include "ED_render.h"
#include "ED_view3d.h"

#include "UI_interface.h"

#include "render_intern.h"

ImBuf* get_brush_icon(Brush *brush)
{
        static const int flags = IB_rect|IB_multilayer|IB_metadata;

        char path[240];
        char *folder;

        if (!(brush->icon_imbuf)) {
                if (brush->flag & BRUSH_CUSTOM_ICON) {

                        if (brush->icon_filepath[0]) {
                                // first use the path directly to try and load the file

                                BLI_strncpy(path, brush->icon_filepath, sizeof(brush->icon_filepath));
                                BLI_path_abs(path, G.main->name);

                                brush->icon_imbuf= IMB_loadiffname(path, flags);

                                // otherwise lets try to find it in other directories
                                if (!(brush->icon_imbuf)) {
                                        folder= BLI_get_folder(BLENDER_DATAFILES, "brushicons");

                                        path[0]= 0;

                                        BLI_make_file_string(G.main->name, path, folder, brush->icon_filepath);

                                        if (path[0])
                                                brush->icon_imbuf= IMB_loadiffname(path, flags);
                                }

                                if (brush->icon_imbuf)
                                        BKE_icon_changed(BKE_icon_getid(&brush->id));
                        }
                }
        }

        if (!(brush->icon_imbuf))
                brush->id.icon_id = 0;

        return brush->icon_imbuf;
}

typedef struct ShaderPreview {
        /* from wmJob */
        void *owner;
        short *stop, *do_update;
        
        Scene *scene;
        ID *id;
        ID *parent;
        MTex *slot;
        
        /* datablocks with nodes need full copy during preview render, glsl uses it too */
        Material *matcopy;
        Tex *texcopy;
        Lamp *lampcopy;
        World *worldcopy;
        
        float col[4];           /* active object color */
        
        int sizex, sizey;
        unsigned int *pr_rect;
        int pr_method;
        
} ShaderPreview;

/* *************************** Preview for buttons *********************** */

static Main *pr_main= NULL;

void ED_preview_init_dbase(void)
{
#ifndef WITH_HEADLESS
        BlendFileData *bfd;
        extern int datatoc_preview_blend_size;
        extern char datatoc_preview_blend[];
        const int fileflags= G.fileflags;
        
        G.fileflags |= G_FILE_NO_UI;
        bfd= BLO_read_from_memory(datatoc_preview_blend, datatoc_preview_blend_size, NULL);
        if (bfd) {
                pr_main= bfd->main;
                
                MEM_freeN(bfd);
        }
        G.fileflags= fileflags;
#endif
}

void ED_preview_free_dbase(void)
{
        if(pr_main)
                free_main(pr_main);
}

static int preview_mat_has_sss(Material *mat, bNodeTree *ntree)
{
        if(mat) {
                if(mat->sss_flag & MA_DIFF_SSS)
                        return 1;
                if(mat->nodetree)
                        if( preview_mat_has_sss(NULL, mat->nodetree))
                                return 1;
        }
        else if(ntree) {
                bNode *node;
                for(node= ntree->nodes.first; node; node= node->next) {
                        if(node->type==NODE_GROUP && node->id) {
                                if( preview_mat_has_sss(NULL, (bNodeTree *)node->id))
                                        return 1;
                        }
                        else if(node->id && ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) {
                                mat= (Material *)node->id;
                                if(mat->sss_flag & MA_DIFF_SSS)
                                        return 1;
                        }
                }
        }
        return 0;
}

/* call this with a pointer to initialize preview scene */
/* call this with NULL to restore assigned ID pointers in preview scene */
static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPreview *sp)
{
        Scene *sce;
        Base *base;
        
        if(pr_main==NULL) return NULL;
        
        sce= pr_main->scene.first;
        if(sce) {
                
                /* this flag tells render to not execute depsgraph or ipos etc */
                sce->r.scemode |= R_PREVIEWBUTS;
                /* set world always back, is used now */
                sce->world= pr_main->world.first;
                /* now: exposure copy */
                if(scene->world) {
                        sce->world->exp= scene->world->exp;
                        sce->world->range= scene->world->range;
                }
                
                sce->r.color_mgt_flag = scene->r.color_mgt_flag;
                
                /* prevent overhead for small renders and icons (32) */
                if(id && sp->sizex < 40)
                        sce->r.xparts= sce->r.yparts= 1;
                else
                        sce->r.xparts= sce->r.yparts= 4;
                
                /* exception: don't color manage texture previews or icons */
                if((id && sp->pr_method==PR_ICON_RENDER) || id_type == ID_TE)
                        sce->r.color_mgt_flag &= ~R_COLOR_MANAGEMENT;
                
                if((id && sp->pr_method==PR_ICON_RENDER) && id_type != ID_WO)
                        sce->r.alphamode= R_ALPHAPREMUL;
                else
                        sce->r.alphamode= R_ADDSKY;

                sce->r.cfra= scene->r.cfra;
                strcpy(sce->r.engine, scene->r.engine);
                
                if(id_type==ID_MA) {
                        Material *mat= NULL, *origmat= (Material *)id;
                        
                        if(origmat) {
                                /* work on a copy */
                                mat= localize_material(origmat);
                                sp->matcopy= mat;
                                BLI_addtail(&pr_main->mat, mat);
                                
                                init_render_material(mat, 0, NULL);             /* call that retrieves mode_l */
                                end_render_material(mat);
                                
                                /* un-useful option */
                                if(sp->pr_method==PR_ICON_RENDER)
                                        mat->shade_flag &= ~MA_OBCOLOR;

                                /* turn on raytracing if needed */
                                if(mat->mode_l & MA_RAYMIRROR)
                                        sce->r.mode |= R_RAYTRACE;
                                if(mat->material_type == MA_TYPE_VOLUME)
                                        sce->r.mode |= R_RAYTRACE;
                                if((mat->mode_l & MA_RAYTRANSP) && (mat->mode_l & MA_TRANSP))
                                        sce->r.mode |= R_RAYTRACE;
                                if(preview_mat_has_sss(mat, NULL))
                                        sce->r.mode |= R_SSS;
                                
                                /* turn off fake shadows if needed */
                                /* this only works in a specific case where the preview.blend contains
                                 * an object starting with 'c' which has a material linked to it (not the obdata)
                                 * and that material has a fake shadow texture in the active texture slot */
                                for(base= sce->base.first; base; base= base->next) {
                                        if(base->object->id.name[2]=='c') {
                                                Material *shadmat= give_current_material(base->object, base->object->actcol);
                                                if(shadmat) {
                                                        if (mat->mode & MA_SHADBUF) shadmat->septex = 0;
                                                        else shadmat->septex |= 1;
                                                }
                                        }
                                }
                                
                                /* turn off bounce lights for volume, 
                                 * doesn't make much visual difference and slows it down too */
                                if(mat->material_type == MA_TYPE_VOLUME) {
                                        for(base= sce->base.first; base; base= base->next) {
                                                if(base->object->type == OB_LAMP) {
                                                        /* if doesn't match 'Lamp.002' --> main key light */
                                                        if( strcmp(base->object->id.name+2, "Lamp.002") != 0 ) {
                                                                base->object->restrictflag |= OB_RESTRICT_RENDER;
                                                        }
                                                }
                                        }
                                }

                                
                                if(sp->pr_method==PR_ICON_RENDER) {
                                        if (mat->material_type == MA_TYPE_HALO) {
                                                sce->lay= 1<<MA_FLAT;
                                        } 
                                        else {
                                                sce->lay= 1<<MA_SPHERE_A;
                                        }
                                }
                                else {
                                        sce->lay= 1<<mat->pr_type;
                                        if(mat->nodetree && sp->pr_method==PR_NODE_RENDER) {
                                                /* two previews, they get copied by wmJob */
                                                ntreeInitPreview(mat->nodetree, sp->sizex, sp->sizey);
                                                ntreeInitPreview(origmat->nodetree, sp->sizex, sp->sizey);
                                        }
                                }
                        }
                        else {
                                sce->r.mode &= ~(R_OSA|R_RAYTRACE|R_SSS);
                                
                        }
                        
                        for(base= sce->base.first; base; base= base->next) {
                                if(base->object->id.name[2]=='p') {
                                        /* copy over object color, in case material uses it */
                                        copy_v4_v4(base->object->col, sp->col);
                                        
                                        if(ELEM4(base->object->type, OB_MESH, OB_CURVE, OB_SURF, OB_MBALL)) {
                                                /* don't use assign_material, it changed mat->id.us, which shows in the UI */
                                                Material ***matar= give_matarar(base->object);
                                                int actcol= MAX2(base->object->actcol > 0, 1) - 1;

                                                if(matar && actcol < base->object->totcol)
                                                        (*matar)[actcol]= mat;
                                        } else if (base->object->type == OB_LAMP) {
                                                base->object->restrictflag &= ~OB_RESTRICT_RENDER;
                                        }
                                }
                        }
                }
                else if(id_type==ID_TE) {
                        Tex *tex= NULL, *origtex= (Tex *)id;
                        
                        if(origtex) {
                                tex= localize_texture(origtex);
                                sp->texcopy= tex;
                                BLI_addtail(&pr_main->tex, tex);
                        }                       
                        sce->lay= 1<<MA_TEXTURE;
                        
                        for(base= sce->base.first; base; base= base->next) {
                                if(base->object->id.name[2]=='t') {
                                        Material *mat= give_current_material(base->object, base->object->actcol);
                                        if(mat && mat->mtex[0]) {
                                                mat->mtex[0]->tex= tex;
                                                
                                                if(tex && sp->slot)
                                                        mat->mtex[0]->which_output = sp->slot->which_output;
                                                
                                                /* show alpha in this case */
                                                if(tex==NULL || (tex->flag & TEX_PRV_ALPHA)) {
                                                        mat->mtex[0]->mapto |= MAP_ALPHA;
                                                        mat->alpha= 0.0f;
                                                }
                                                else {
                                                        mat->mtex[0]->mapto &= ~MAP_ALPHA;
                                                        mat->alpha= 1.0f;
                                                }
                                        }
                                }
                        }

                        if(tex && tex->nodetree && sp->pr_method==PR_NODE_RENDER) {
                                /* two previews, they get copied by wmJob */
                                ntreeInitPreview(origtex->nodetree, sp->sizex, sp->sizey);
                                ntreeInitPreview(tex->nodetree, sp->sizex, sp->sizey);
                        }
                }
                else if(id_type==ID_LA) {
                        Lamp *la= NULL, *origla= (Lamp *)id;

                        /* work on a copy */
                        if(origla) {
                                la= localize_lamp(origla);
                                sp->lampcopy= la;
                                BLI_addtail(&pr_main->lamp, la);
                        }
                        
                        if(la && la->type==LA_SUN && (la->sun_effect_type & LA_SUN_EFFECT_SKY)) {
                                sce->lay= 1<<MA_ATMOS;
                                sce->world= scene->world;
                                sce->camera= (Object *)BLI_findstring(&pr_main->object, "CameraAtmo", offsetof(ID, name)+2);
                        }
                        else {
                                sce->lay= 1<<MA_LAMP;
                                sce->world= NULL;
                                sce->camera= (Object *)BLI_findstring(&pr_main->object, "Camera", offsetof(ID, name)+2);
                        }
                        sce->r.mode &= ~R_SHADOW;
                        
                        for(base= sce->base.first; base; base= base->next) {
                                if(base->object->id.name[2]=='p') {
                                        if(base->object->type==OB_LAMP)
                                                base->object->data= la;
                                }
                        }
                }
                else if(id_type==ID_WO) {
                        World *wrld= NULL, *origwrld= (World *)id;

                        if(origwrld) {
                                wrld= localize_world(origwrld);
                                sp->worldcopy= wrld;
                                BLI_addtail(&pr_main->world, wrld);
                        }

                        sce->lay= 1<<MA_SKY;
                        sce->world= wrld;
                }
                
                return sce;
        }
        
        return NULL;
}

/* new UI convention: draw is in pixel space already. */
/* uses ROUNDBOX button in block to get the rect */
static int ed_preview_draw_rect(ScrArea *sa, Scene *sce, ID *id, int split, int first, rcti *rect, rcti *newrect)
{
        Render *re;
        RenderResult rres;
        char name[32];
        int do_gamma_correct=0;
        int offx=0, newx= rect->xmax-rect->xmin, newy= rect->ymax-rect->ymin;

        if (id && GS(id->name) != ID_TE) {
                /* exception: don't color manage texture previews - show the raw values */
                if (sce) do_gamma_correct = sce->r.color_mgt_flag & R_COLOR_MANAGEMENT;
        }

        if(!split || first) sprintf(name, "Preview %p", (void *)sa);
        else sprintf(name, "SecondPreview %p", (void *)sa);

        if(split) {
                if(first) {
                        offx= 0;
                        newx= newx/2;
                }
                else {
                        offx= newx/2;
                        newx= newx - newx/2;
                }
        }

        re= RE_GetRender(name);
        RE_AcquireResultImage(re, &rres);

        if(rres.rectf) {
                
                if(ABS(rres.rectx-newx)<2 && ABS(rres.recty-newy)<2) {
                        newrect->xmax= MAX2(newrect->xmax, rect->xmin + rres.rectx + offx);
                        newrect->ymax= MAX2(newrect->ymax, rect->ymin + rres.recty);

                        glaDrawPixelsSafe_to32(rect->xmin+offx, rect->ymin, rres.rectx, rres.recty, rres.rectx, rres.rectf, do_gamma_correct);

                        RE_ReleaseResultImage(re);
                        return 1;
                }
        }

        RE_ReleaseResultImage(re);
        return 0;
}

void ED_preview_draw(const bContext *C, void *idp, void *parentp, void *slotp, rcti *rect)
{
        if(idp) {
                ScrArea *sa= CTX_wm_area(C);
                Scene *sce = CTX_data_scene(C);
                ID *id = (ID *)idp;
                ID *parent= (ID *)parentp;
                MTex *slot= (MTex *)slotp;
                SpaceButs *sbuts= sa->spacedata.first;
                rcti newrect;
                int ok;
                int newx= rect->xmax-rect->xmin, newy= rect->ymax-rect->ymin;

                newrect.xmin= rect->xmin;
                newrect.xmax= rect->xmin;
                newrect.ymin= rect->ymin;
                newrect.ymax= rect->ymin;

                if(parent) {
                        ok = ed_preview_draw_rect(sa, sce, id, 1, 1, rect, &newrect);
                        ok &= ed_preview_draw_rect(sa, sce, parent, 1, 0, rect, &newrect);
                }
                else
                        ok = ed_preview_draw_rect(sa, sce, id, 0, 0, rect, &newrect);

                if(ok)
                        *rect= newrect;

                /* check for spacetype... */
                if(sbuts->spacetype==SPACE_BUTS && sbuts->preview) {
                        sbuts->preview= 0;
                        ok= 0;
                }
        
                if(ok==0) {
                        ED_preview_shader_job(C, sa, id, parent, slot, newx, newy, PR_BUTS_RENDER);
                }
        }       
}

/* **************************** new shader preview system ****************** */

/* inside thread, called by renderer, sets job update value */
static void shader_preview_draw(void *spv, RenderResult *UNUSED(rr), volatile struct rcti *UNUSED(rect))
{
        ShaderPreview *sp= spv;
        
        *(sp->do_update)= 1;
}

/* called by renderer, checks job value */
static int shader_preview_break(void *spv)
{
        ShaderPreview *sp= spv;

        return *(sp->stop);
}

/* outside thread, called before redraw notifiers, it moves finished preview over */
static void shader_preview_updatejob(void *spv)
{
        ShaderPreview *sp= spv;
        
        if(sp->id) {
                if(sp->pr_method==PR_NODE_RENDER) {
                        if( GS(sp->id->name) == ID_MA) {
                                Material *mat= (Material *)sp->id;
                                
                                if(sp->matcopy && mat->nodetree && sp->matcopy->nodetree)
                                        ntreeLocalSync(sp->matcopy->nodetree, mat->nodetree);
                        }
                        else if( GS(sp->id->name) == ID_TE) {
                                Tex *tex= (Tex *)sp->id;
                                
                                if(sp->texcopy && tex->nodetree && sp->texcopy->nodetree)
                                        ntreeLocalSync(sp->texcopy->nodetree, tex->nodetree);
                        }
                }               
        }
}

static void shader_preview_render(ShaderPreview *sp, ID *id, int split, int first)
{
        Render *re;
        Scene *sce;
        float oldlens;
        short idtype= GS(id->name);
        char name[32];
        int sizex;
        
        /* get the stuff from the builtin preview dbase */
        sce= preview_prepare_scene(sp->scene, id, idtype, sp); // XXX sizex
        if(sce==NULL) return;
        
        if(!split || first) sprintf(name, "Preview %p", sp->owner);
        else sprintf(name, "SecondPreview %p", sp->owner);
        re= RE_GetRender(name);
        
        /* full refreshed render from first tile */
        if(re==NULL)
                re= RE_NewRender(name);
                
        /* sce->r gets copied in RE_InitState! */
        sce->r.scemode &= ~(R_MATNODE_PREVIEW|R_TEXNODE_PREVIEW);
        sce->r.scemode &= ~R_NO_IMAGE_LOAD;

        if(sp->pr_method==PR_ICON_RENDER) {
                sce->r.scemode |= R_NO_IMAGE_LOAD;
                sce->r.mode |= R_OSA;
        }
        else if(sp->pr_method==PR_NODE_RENDER) {
                if(idtype == ID_MA) sce->r.scemode |= R_MATNODE_PREVIEW;
                else if(idtype == ID_TE) sce->r.scemode |= R_TEXNODE_PREVIEW;
                sce->r.mode &= ~R_OSA;
        }
        else {  /* PR_BUTS_RENDER */
                sce->r.mode |= R_OSA;
        }

        /* in case of split preview, use border render */
        if(split) {
                if(first) sizex= sp->sizex/2;
                else sizex= sp->sizex - sp->sizex/2;
        }
        else sizex= sp->sizex;

        /* allocates or re-uses render result */
        sce->r.xsch= sizex;
        sce->r.ysch= sp->sizey;
        sce->r.size= 100;

        /* callbacs are cleared on GetRender() */
        if(ELEM(sp->pr_method, PR_BUTS_RENDER, PR_NODE_RENDER)) {
                RE_display_draw_cb(re, sp, shader_preview_draw);
        }
        /* set this for all previews, default is react to G.afbreek still */
        RE_test_break_cb(re, sp, shader_preview_break);
        
        /* lens adjust */
        oldlens= ((Camera *)sce->camera->data)->lens;
        if(sizex > sp->sizey)
                ((Camera *)sce->camera->data)->lens *= (float)sp->sizey/(float)sizex;

        /* entire cycle for render engine */
        RE_PreviewRender(re, pr_main, sce);

        ((Camera *)sce->camera->data)->lens= oldlens;

        /* handle results */
        if(sp->pr_method==PR_ICON_RENDER) {
                // char *rct= (char *)(sp->pr_rect + 32*16 + 16);
                
                if(sp->pr_rect)
                        RE_ResultGet32(re, sp->pr_rect);
        }
        else {
                /* validate owner */
                //if(ri->rect==NULL)
                //      ri->rect= MEM_mallocN(sizeof(int)*ri->pr_rectx*ri->pr_recty, "BIF_previewrender");
                //RE_ResultGet32(re, ri->rect);
        }

        /* unassign the pointers, reset vars */
        preview_prepare_scene(sp->scene, NULL, GS(id->name), sp);
        
        /* XXX bad exception, end-exec is not being called in render, because it uses local main */
//      if(idtype == ID_TE) {
//              Tex *tex= (Tex *)id;
//              if(tex->use_nodes && tex->nodetree)
//                      ntreeEndExecTree(tex->nodetree);
//      }

}

/* runs inside thread for material and icons */
static void shader_preview_startjob(void *customdata, short *stop, short *do_update)
{
        ShaderPreview *sp= customdata;

        sp->stop= stop;
        sp->do_update= do_update;

        if(sp->parent) {
                shader_preview_render(sp, sp->id, 1, 1);
                shader_preview_render(sp, sp->parent, 1, 0);
        }
        else
                shader_preview_render(sp, sp->id, 0, 0);

        *do_update= 1;
}

static void shader_preview_free(void *customdata)
{
        ShaderPreview *sp= customdata;
        
        if(sp->matcopy) {
                struct IDProperty *properties;
                int a;
                
                /* node previews */
                shader_preview_updatejob(sp);
                
                /* get rid of copied material */
                BLI_remlink(&pr_main->mat, sp->matcopy);
                
                /* free_material decrements texture, prevent this. hack alert! */
                for(a=0; a<MAX_MTEX; a++) {
                        MTex *mtex= sp->matcopy->mtex[a];
                        if(mtex && mtex->tex) mtex->tex= NULL;
                }
                
                free_material(sp->matcopy);

                properties= IDP_GetProperties((ID *)sp->matcopy, FALSE);
                if (properties) {
                        IDP_FreeProperty(properties);
                        MEM_freeN(properties);
                }
                MEM_freeN(sp->matcopy);
        }
        if(sp->texcopy) {
                struct IDProperty *properties;
                /* node previews */
                shader_preview_updatejob(sp);
                
                /* get rid of copied texture */
                BLI_remlink(&pr_main->tex, sp->texcopy);
                free_texture(sp->texcopy);
                
                properties= IDP_GetProperties((ID *)sp->texcopy, FALSE);
                if (properties) {
                        IDP_FreeProperty(properties);
                        MEM_freeN(properties);
                }
                MEM_freeN(sp->texcopy);
        }
        if(sp->worldcopy) {
                struct IDProperty *properties;
                /* node previews */
                shader_preview_updatejob(sp);
                
                /* get rid of copied world */
                BLI_remlink(&pr_main->world, sp->worldcopy);
                free_world(sp->worldcopy);
                
                properties= IDP_GetProperties((ID *)sp->worldcopy, FALSE);
                if (properties) {
                        IDP_FreeProperty(properties);
                        MEM_freeN(properties);
                }
                MEM_freeN(sp->worldcopy);
        }
        if(sp->lampcopy) {
                struct IDProperty *properties;
                /* node previews */
                shader_preview_updatejob(sp);
                
                /* get rid of copied lamp */
                BLI_remlink(&pr_main->lamp, sp->lampcopy);
                free_lamp(sp->lampcopy);
                
                properties= IDP_GetProperties((ID *)sp->lampcopy, FALSE);
                if (properties) {
                        IDP_FreeProperty(properties);
                        MEM_freeN(properties);
                }
                MEM_freeN(sp->lampcopy);
        }
        
        MEM_freeN(sp);
}

/* ************************* icon preview ********************** */

static void icon_copy_rect(ImBuf *ibuf, unsigned int w, unsigned int h, unsigned int *rect)
{
        struct ImBuf *ima;
        unsigned int *drect, *srect;
        float scaledx, scaledy;
        short ex, ey, dx, dy;

        /* paranoia test */
        if(ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL))
                return;
        
        /* waste of cpu cyles... but the imbuf API has no other way to scale fast (ton) */
        ima = IMB_dupImBuf(ibuf);
        
        if (!ima) 
                return;
        
        if (ima->x > ima->y) {
                scaledx = (float)w;
                scaledy =  ( (float)ima->y/(float)ima->x )*(float)w;
        }
        else {                  
                scaledx =  ( (float)ima->x/(float)ima->y )*(float)h;
                scaledy = (float)h;
        }
        
        ex = (short)scaledx;
        ey = (short)scaledy;
        
        dx = (w - ex) / 2;
        dy = (h - ey) / 2;
        
        IMB_scalefastImBuf(ima, ex, ey);
        
        /* if needed, convert to 32 bits */
        if(ima->rect==NULL)
                IMB_rect_from_float(ima);

        srect = ima->rect;
        drect = rect;

        drect+= dy*w+dx;
        for (;ey > 0; ey--){            
                memcpy(drect,srect, ex * sizeof(int));
                drect += w;
                srect += ima->x;
        }

        IMB_freeImBuf(ima);
}

static void set_alpha(char *cp, int sizex, int sizey, char alpha) 
{
        int a, size= sizex*sizey;

        for(a=0; a<size; a++, cp+=4)
                cp[3]= alpha;
}

static void icon_preview_startjob(void *customdata, short *stop, short *do_update)
{
        ShaderPreview *sp= customdata;
        ID *id= sp->id;
        short idtype= GS(id->name);

        if(idtype == ID_IM) {
                Image *ima= (Image*)id;
                ImBuf *ibuf= NULL;
                ImageUser iuser= {NULL};

                /* ima->ok is zero when Image cannot load */
                if(ima==NULL || ima->ok==0)
                        return;

                /* setup dummy image user */
                iuser.ok= iuser.framenr= 1;
                iuser.scene= sp->scene;
                
                /* elubie: this needs to be changed: here image is always loaded if not
                   already there. Very expensive for large images. Need to find a way to 
                   only get existing ibuf */
                ibuf = BKE_image_get_ibuf(ima, &iuser);
                if(ibuf==NULL || ibuf->rect==NULL)
                        return;
                
                icon_copy_rect(ibuf, sp->sizex, sp->sizey, sp->pr_rect);

                *do_update= 1;
        }
        else if(idtype == ID_BR) {
                Brush *br= (Brush*)id;

                br->icon_imbuf= get_brush_icon(br);

                memset(sp->pr_rect, 0x888888, sp->sizex*sp->sizey*sizeof(unsigned int));

                if(!(br->icon_imbuf) || !(br->icon_imbuf->rect))
                        return;

                icon_copy_rect(br->icon_imbuf, sp->sizex, sp->sizey, sp->pr_rect);

                *do_update= 1;
        }
        else {
                /* re-use shader job */
                shader_preview_startjob(customdata, stop, do_update);

                /* world is rendered with alpha=0, so it wasn't displayed 
                   this could be render option for sky to, for later */
                if(idtype == ID_WO) {
                        set_alpha((char*)sp->pr_rect, sp->sizex, sp->sizey, 255);
                }
                else if(idtype == ID_MA) {
                        Material* ma = (Material*)id;

                        if(ma->material_type == MA_TYPE_HALO)
                                set_alpha((char*)sp->pr_rect, sp->sizex, sp->sizey, 255);
                }
        }
}

/* use same function for icon & shader, so the job manager
   does not run two of them at the same time. */

static void common_preview_startjob(void *customdata, short *stop, short *do_update, float *UNUSED(progress))
{
        ShaderPreview *sp= customdata;

        if(sp->pr_method == PR_ICON_RENDER)
                icon_preview_startjob(customdata, stop, do_update);
        else
                shader_preview_startjob(customdata, stop, do_update);
}

static void common_preview_endjob(void *customdata)
{
        ShaderPreview *sp= customdata;

        if(sp->id && GS(sp->id->name) == ID_BR)
                WM_main_add_notifier(NC_BRUSH|NA_EDITED, sp->id);
}

/* exported functions */

void ED_preview_icon_job(const bContext *C, void *owner, ID *id, unsigned int *rect, int sizex, int sizey)
{
        wmJob *steve;
        ShaderPreview *sp;
        
        /* suspended start means it starts after 1 timer step, see WM_jobs_timer below */
        steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner, "Icon Preview", WM_JOB_EXCL_RENDER|WM_JOB_SUSPEND);
        sp= MEM_callocN(sizeof(ShaderPreview), "shader preview");

        /* customdata for preview thread */
        sp->scene= CTX_data_scene(C);
        sp->owner= id;
        sp->sizex= sizex;
        sp->sizey= sizey;
        sp->pr_method= PR_ICON_RENDER;
        sp->pr_rect= rect;
        sp->id = id;

        /* setup job */
        WM_jobs_customdata(steve, sp, shader_preview_free);
        WM_jobs_timer(steve, 0.25, NC_MATERIAL, NC_MATERIAL);
        WM_jobs_callbacks(steve, common_preview_startjob, NULL, NULL, common_preview_endjob);

        WM_jobs_start(CTX_wm_manager(C), steve);
}

void ED_preview_shader_job(const bContext *C, void *owner, ID *id, ID *parent, MTex *slot, int sizex, int sizey, int method)
{
        Object *ob= CTX_data_active_object(C);
        wmJob *steve;
        ShaderPreview *sp;

        steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner, "Shader Preview", WM_JOB_EXCL_RENDER);
        sp= MEM_callocN(sizeof(ShaderPreview), "shader preview");

        /* customdata for preview thread */
        sp->scene= CTX_data_scene(C);
        sp->owner= owner;
        sp->sizex= sizex;
        sp->sizey= sizey;
        sp->pr_method= method;
        sp->id = id;
        sp->parent= parent;
        sp->slot= slot;
        if(ob && ob->totcol) copy_v4_v4(sp->col, ob->col);
        else sp->col[0]= sp->col[1]= sp->col[2]= sp->col[3]= 1.0f;
        
        /* setup job */
        WM_jobs_customdata(steve, sp, shader_preview_free);
        WM_jobs_timer(steve, 0.1, NC_MATERIAL, NC_MATERIAL);
        WM_jobs_callbacks(steve, common_preview_startjob, NULL, shader_preview_updatejob, NULL);
        
        WM_jobs_start(CTX_wm_manager(C), steve);
}

void ED_preview_kill_jobs(const struct bContext *C)
{
        wmWindowManager *wm= CTX_wm_manager(C);
        if(wm)
                WM_jobs_kill(wm, NULL, common_preview_startjob);
}