#include "renderer_light.hpp"

#include <functional>
#include <math.h>
#include <string>
#include <vector>

#include "tinythread.h"

#include "LuaTools.h"

#include "modules/Gui.h"
#include "modules/Maps.h"
#include "modules/Screen.h"
#include "modules/Units.h"

#include "df/block_square_event_material_spatterst.h"
#include "df/building.h"
#include "df/building_doorst.h"
#include "df/building_floodgatest.h"
#include "df/flow_info.h"
#include "df/graphic.h"
#include "df/item.h"
#include "df/items_other_id.h"
#include "df/plant.h"
#include "df/plant_raw.h"
#include "df/unit.h"
#include "df/viewscreen_dungeonmodest.h"
#include "df/viewscreen_dwarfmodest.h"
#include "df/world.h"

using df::global::gps;
using namespace DFHack;
using df::coord2d;
using namespace tthread;

const float RootTwo = 1.4142135623730950488016887242097f;


bool isInRect(const coord2d& pos,const rect2d& rect)
{
    if(pos.x>=rect.first.x && pos.y>=rect.first.y && pos.x<rect.second.x && pos.y<rect.second.y)
        return true;
    return false;
}

lightingEngineViewscreen::~lightingEngineViewscreen()
{
    threading.shutdown();
}

lightSource::lightSource(rgbf power,int radius):power(power),flicker(false)
{
    if(radius >= 0)
        this->radius = radius;
    else
    {
        float levelDim = 0.2f;//TODO this is not correct if you change config
        float totalPower = power.r;
        if(totalPower < power.g)totalPower = power.g;
        if(totalPower < power.b)totalPower = power.b;
        if(totalPower > 0 && levelDim > 0)
            this->radius = (int)((log(levelDim/totalPower)/log(0.85f))) + 1;
        else
            this->radius = 0;
    }
}

rect2d getMapViewport()
{
    const int AREA_MAP_WIDTH = 23;
    const int MENU_WIDTH = 30;
    if(!gps || !df::viewscreen_dwarfmodest::_identity.is_instance(DFHack::Gui::getCurViewscreen()))
    {
        if(gps && df::viewscreen_dungeonmodest::_identity.is_instance(DFHack::Gui::getCurViewscreen()))
        {
            return mkrect_wh(0,0,gps->dimx,gps->dimy);
        }
        else
            return mkrect_wh(0,0,0,0);

    }
    int w=gps->dimx;
    int h=gps->dimy;
    int view_height=h-2;
    int area_x2 = w-AREA_MAP_WIDTH-2;
    int menu_x2=w-MENU_WIDTH-2;
    int menu_x1=area_x2-MENU_WIDTH-1;
    int view_rb=w-1;

    int area_pos=*df::global::ui_area_map_width;
    int menu_pos=*df::global::ui_menu_width;
    if(area_pos<3)
    {
        view_rb=area_x2;
    }
    if (menu_pos<area_pos || df::global::ui->main.mode!=0)
    {
        if (menu_pos >= area_pos)
            menu_pos = area_pos-1;
        int menu_x = menu_x2;
        if(menu_pos < 2) menu_x = menu_x1;
        view_rb = menu_x;
    }
    return mkrect_wh(1,1,view_rb,view_height+1);
}
lightingEngineViewscreen::lightingEngineViewscreen(renderer_light* target):lightingEngine(target),doDebug(false),threading(this)
{
    reinit();
    defaultSettings();
    int numTreads=tthread::thread::hardware_concurrency();
    if(numTreads==0)numTreads=1;
    threading.start(numTreads);
}

void lightingEngineViewscreen::reinit()
{
    if(!gps)
        return;
    w=gps->dimx;
    h=gps->dimy;
    size_t size=w*h;
    lightMap.resize(size,rgbf(1,1,1));
    ocupancy.resize(size);
    lights.resize(size);
}

void plotCircle(int xm, int ym, int r,const std::function<void(int,int)>& setPixel)
{
    int x = -r, y = 0, err = 2-2*r; /* II. Quadrant */
    do {
        setPixel(xm-x, ym+y); /*   I. Quadrant */
        setPixel(xm-y, ym-x); /*  II. Quadrant */
        setPixel(xm+x, ym-y); /* III. Quadrant */
        setPixel(xm+y, ym+x); /*  IV. Quadrant */
        r = err;
        if (r <= y) err += ++y*2+1;           /* e_xy+e_y < 0 */
        if (r > x || err > y) err += ++x*2+1; /* e_xy+e_x > 0 or no 2nd y-step */
    } while (x < 0);
}
void plotSquare(int xm, int ym, int r,const std::function<void(int,int)>& setPixel)
{
    for(int x = 0; x <= r; x++)
    {
        setPixel(xm+r, ym+x); /*   I.1 Quadrant */
        setPixel(xm+x, ym+r); /*   I.2 Quadrant */
        setPixel(xm+r, ym-x); /*   II.1 Quadrant */
        setPixel(xm+x, ym-r); /*   II.2 Quadrant */
        setPixel(xm-r, ym-x); /*   III.1 Quadrant */
        setPixel(xm-x, ym-r); /*   III.2 Quadrant */
        setPixel(xm-r, ym+x); /*   IV.1 Quadrant */
        setPixel(xm-x, ym+r); /*   IV.2 Quadrant */
    }
}
void plotLine(int x0, int y0, int x1, int y1,rgbf power,const std::function<rgbf(rgbf,int,int,int,int)>& setPixel)
{
    int dx =  abs(x1-x0), sx = x0<x1 ? 1 : -1;
    int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
    int err = dx+dy, e2; /* error value e_xy */
    int rdx=0;
    int rdy=0;
    for(;;){  /* loop */
        if(rdx!=0 || rdy!=0) //dirty hack to skip occlusion on the first tile.
        {
            power=setPixel(power,rdx,rdy,x0,y0);
            if(power.dot(power)<0.00001f)
                return ;
        }
        if (x0==x1 && y0==y1) break;
        e2 = 2*err;
        rdx=rdy=0;
        if (e2 >= dy) { err += dy; x0 += sx; rdx=sx;} /* e_xy+e_x > 0 */
        if (e2 <= dx) { err += dx; y0 += sy; rdy=sy;} /* e_xy+e_y < 0 */
    }
    return ;
}
void plotLineDiffuse(int x0, int y0, int x1, int y1,rgbf power,int num_diffuse,const std::function<rgbf(rgbf,int,int,int,int)>& setPixel,bool skip_hack=false)
{

    int dx =  abs(x1-x0), sx = x0<x1 ? 1 : -1;
    int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
    int dsq=dx*dx+dy*dy;
    int err = dx+dy, e2; /* error value e_xy */
    int rdx=0;
    int rdy=0;
    for(;;){  /* loop */
        if(rdx!=0 || rdy!=0 || skip_hack) //dirty hack to skip occlusion on the first tile.
        {
            power=setPixel(power,rdx,rdy,x0,y0);
            if(power.dot(power)<0.00001f)
                return ;
        }
        if (x0==x1 && y0==y1) break;
        e2 = 2*err;
        rdx=rdy=0;
        if (e2 >= dy) { err += dy; x0 += sx; rdx=sx;} /* e_xy+e_x > 0 */
        if (e2 <= dx) { err += dx; y0 += sy; rdy=sy;} /* e_xy+e_y < 0 */

        if(num_diffuse>0 && dsq/4<(x1-x0)*(x1-x0)+(y1-y0)*(y1-y0))//reached center?
        {
            const float betta=0.25;
            int nx=y1-y0; //right angle
            int ny=x1-x0;
            if((nx*nx+ny*ny)*betta*betta>2)
            {
                plotLineDiffuse(x0,y0,x0+nx*betta,y0+ny*betta,power,num_diffuse-1,setPixel,true);
                plotLineDiffuse(x0,y0,x0-nx*betta,y0-ny*betta,power,num_diffuse-1,setPixel,true);
            }
        }
    }
    return ;
}
void plotLineAA(int x0, int y0, int x1, int y1,rgbf power,const std::function<rgbf(rgbf,int,int,int,int)>& setPixelAA)
{
    int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
    int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
    int err = dx-dy, e2, x2;                       /* error value e_xy */
    int ed = dx+dy == 0 ? 1 : sqrt((float)dx*dx+(float)dy*dy);
    int rdx=0;
    int rdy=0;
    int lrdx,lrdy;
    rgbf sumPower;
    for ( ; ; ){                                         /* pixel loop */
        float strsum=0;
        float str=1-abs(err-dx+dy)/(float)ed;
        strsum=str;
        sumPower=setPixelAA(power*str,rdx,rdy,x0,y0);
        e2 = err; x2 = x0;
        lrdx=rdx;
        lrdy=rdy;
        rdx=rdy=0;
        if (2*e2 >= -dx) {                                    /* x step */
            if (x0 == x1) break;

            if (e2+dy < ed)
                {
                    str=1-(e2+dy)/(float)ed;
                    sumPower+=setPixelAA(power*str,lrdx,lrdy,x0,y0+sy);
                    strsum+=str;
                }
            err -= dy; x0 += sx; rdx=sx;
        }
        if (2*e2 <= dy) {                                     /* y step */
            if (y0 == y1) break;

            if (dx-e2 < ed)
                {
                    str=1-(dx-e2)/(float)ed;
                    sumPower+=setPixelAA(power*str,lrdx,lrdy,x2+sx,y0);
                    strsum+=str;
                }
            err += dx; y0 += sy; rdy=sy;
        }
        if(strsum<0.001f)
            return;
        sumPower=sumPower/strsum;
        if(sumPower.dot(sumPower)<0.00001f)
            return;
        power=sumPower;
    }
}
rgbf blendMax(const rgbf& a,const rgbf& b)
{
    return rgbf(std::max(a.r,b.r),std::max(a.g,b.g),std::max(a.b,b.b));
}
rgbf blend(const rgbf& a,const rgbf& b)
{
    return blendMax(a,b);
}
void lightingEngineViewscreen::clear()
{
    lightMap.assign(lightMap.size(),rgbf(1,1,1));
    tthread::lock_guard<tthread::fast_mutex> guard(myRenderer->dataMutex);
    if(lightMap.size()==myRenderer->lightGrid.size())
    {
        std::swap(myRenderer->lightGrid,lightMap);
        myRenderer->invalidate();
    }
}
void lightingEngineViewscreen::calculate()
{
    if(lightMap.size()!=myRenderer->lightGrid.size())
    {
        reinit();
        myRenderer->invalidate();//needs a lock?
    }
    rect2d vp=getMapViewport();
    const rgbf dim(levelDim,levelDim,levelDim);
    lightMap.assign(lightMap.size(),rgbf(1,1,1));
    lights.assign(lights.size(),lightSource());
    for(int i=vp.first.x;i<vp.second.x;i++)
    for(int j=vp.first.y;j<vp.second.y;j++)
    {
        lightMap[getIndex(i,j)]=dim;
    }
    doOcupancyAndLights();
    threading.signalDoneOcclusion();
    threading.waitForWrites();
}
void lightingEngineViewscreen::updateWindow()
{
    tthread::lock_guard<tthread::fast_mutex> guard(myRenderer->dataMutex);
    if(lightMap.size()!=myRenderer->lightGrid.size())
    {
        reinit();
        myRenderer->invalidate();
        return;
    }

    bool isAdventure=(*df::global::gametype==df::game_type::ADVENTURE_ARENA)||
        (*df::global::gametype==df::game_type::ADVENTURE_MAIN);
    if(isAdventure)
    {
        fixAdvMode(adv_mode);
    }

    if(doDebug)
        std::swap(ocupancy,myRenderer->lightGrid);
    else
        std::swap(lightMap,myRenderer->lightGrid);
    rect2d vp=getMapViewport();

    myRenderer->invalidateRect(vp.first.x,vp.first.y,vp.second.x-vp.first.x,vp.second.y-vp.first.y);
}
void lightingEngineViewscreen::preRender()
{

}
void lightingEngineViewscreen::fixAdvMode(int mode)
{

    MapExtras::MapCache mc;
    const rgbf dim(levelDim,levelDim,levelDim);
    rect2d vp=getMapViewport();
    int window_x=*df::global::window_x;
    int window_y=*df::global::window_y;
    int window_z=*df::global::window_z;
    coord2d vpSize=rect_size(vp);
    //mode 0-> make dark non-visible parts
    if(mode==0)
    {
        for(int x=vp.first.x;x<vp.second.x;x++)
            for(int y=vp.first.y;y<vp.second.y;y++)
            {
                df::tile_designation d=mc.designationAt(DFCoord(window_x+x,window_y+y,window_z));
                if(d.bits.pile!=1)
                {
                    lightMap[getIndex(x,y)]=dim;
                }
            }
    }
    //mode 1-> make everything visible, let the lighting hide stuff
    else if(mode==1)
    {
        for(int x=vp.first.x;x<vp.second.x;x++)
            for(int y=vp.first.y;y<vp.second.y;y++)
            {
                df::tile_designation d=mc.designationAt(DFCoord(window_x+x,window_y+y,window_z));
                d.bits.dig=df::tile_dig_designation::Default;//TODO add union and flag there
                d.bits.hidden=0;
                d.bits.pile = 1;
                mc.setDesignationAt(DFCoord(window_x+x,window_y+y,window_z),d);
            }
    }
}
void lightSource::combine(const lightSource& other)
{
    power=blend(power,other.power);
    radius=std::max(other.radius,radius);//hack... but who cares
}
bool lightingEngineViewscreen::addLight(int tileId,const lightSource& light)
{
    bool wasLight=lights[tileId].radius>0;
    lights[tileId].combine(light);
    if(light.flicker)
        lights[tileId].flicker=true;
    return wasLight;
}
void lightingEngineViewscreen::addOclusion(int tileId,const rgbf& c,float thickness)
{
    if(thickness > 0.999 && thickness < 1.001)
        ocupancy[tileId]*=c;
    else
        ocupancy[tileId]*=(c.pow(thickness));
}
rgbf getStandartColor(int colorId)
{
    return rgbf(df::global::enabler->ccolor[colorId][0]/255.0f,
        df::global::enabler->ccolor[colorId][1]/255.0f,
        df::global::enabler->ccolor[colorId][2]/255.0f);
}
int getPlantNumber(const std::string& id)
{
    std::vector<df::plant_raw*>& vec=df::plant_raw::get_vector();
    for(int i=0;i<vec.size();i++)
    {
        if(vec[i]->id==id)
            return i;
    }
    return -1;
}
void addPlant(const std::string& id,std::map<int,lightSource>& map,const lightSource& v)
{
    int nId=getPlantNumber(id);
    if(nId>0)
    {
        map[nId]=v;
    }
}
matLightDef* lightingEngineViewscreen::getMaterialDef( int matType,int matIndex )
{
    auto it=matDefs.find(std::make_pair(matType,matIndex));
    if(it!=matDefs.end())
        return &it->second;
    else
        return NULL;
}
buildingLightDef* lightingEngineViewscreen::getBuildingDef( df::building* bld )
{
    auto it=buildingDefs.find(std::make_tuple((int)bld->getType(),(int)bld->getSubtype(),(int)bld->getCustomType()));
    if(it!=buildingDefs.end())
        return &it->second;
    else
        return NULL;
}
creatureLightDef* lightingEngineViewscreen::getCreatureDef(df::unit* u)
{
    auto it=creatureDefs.find(std::make_pair(int(u->race),int(u->caste)));
    if(it!=creatureDefs.end())
        return &it->second;
    else
    {
        auto it2=creatureDefs.find(std::make_pair(int(u->race),int(-1)));
        if(it2!=creatureDefs.end())
            return &it2->second;
        else
            return NULL;
    }
}
itemLightDef* lightingEngineViewscreen::getItemDef(df::item* it)
{
    auto iter=itemDefs.find(std::make_pair(int(it->getType()),int(it->getSubtype())));
    if(iter!=itemDefs.end())
        return &iter->second;
    else
    {
        auto iter2=itemDefs.find(std::make_pair(int(it->getType()),int(-1)));
        if(iter2!=itemDefs.end())
            return &iter2->second;
        else
            return NULL;
    }
}
void lightingEngineViewscreen::applyMaterial(int tileId,const matLightDef& mat,float size, float thickness)
{
    if(mat.isTransparent)
    {
       addOclusion(tileId,mat.transparency,thickness);
    }
    else
        ocupancy[tileId]=rgbf(0,0,0);
    if(mat.isEmiting)
        addLight(tileId,mat.makeSource(size));
}
bool lightingEngineViewscreen::applyMaterial(int tileId,int matType,int matIndex,float size,float thickness,const matLightDef* def)
{
    matLightDef* m=getMaterialDef(matType,matIndex);
    if(m)
    {
        applyMaterial(tileId,*m,size,thickness);
        return true;
    }
    else if(def)
    {
        applyMaterial(tileId,*def,size,thickness);
    }
    return false;
}
rgbf lightingEngineViewscreen::propogateSun(MapExtras::Block* b, int x,int y,const rgbf& in,bool lastLevel)
{
    //TODO unify under addLight/addOclusion
    const rgbf matStairCase(0.9f,0.9f,0.9f);
    rgbf ret=in;
    coord2d innerCoord(x,y);
    df::tiletype type = b->staticTiletypeAt(innerCoord);
    df::tile_designation d = b->DesignationAt(innerCoord);
    //df::tile_occupancy o = b->OccupancyAt(innerCoord);
    df::tiletype_shape shape = ENUM_ATTR(tiletype,shape,type);
    df::tiletype_shape_basic basic_shape = ENUM_ATTR(tiletype_shape, basic_shape, shape);
    DFHack::t_matpair mat=b->staticMaterialAt(innerCoord);
    df::tiletype_material tileMat= ENUM_ATTR(tiletype,material,type);

    matLightDef* lightDef;
    if(tileMat==df::tiletype_material::FROZEN_LIQUID)
    {
        df::tiletype typeIce = b->tiletypeAt(innerCoord);
        df::tiletype_shape shapeIce = ENUM_ATTR(tiletype,shape,typeIce);
        df::tiletype_shape_basic basicShapeIce = ENUM_ATTR(tiletype_shape,basic_shape,shapeIce);
        if(basicShapeIce==df::tiletype_shape_basic::Wall)
            ret*=matIce.transparency;
        else if(basicShapeIce==df::tiletype_shape_basic::Floor || basicShapeIce==df::tiletype_shape_basic::Ramp || shapeIce==df::tiletype_shape::STAIR_UP)
            if(!lastLevel)
                ret*=matIce.transparency.pow(1.0f/7.0f);
    }

    lightDef=getMaterialDef(mat.mat_type,mat.mat_index);

    if(!lightDef || !lightDef->isTransparent)
        lightDef=&matWall;
    if(basic_shape==df::tiletype_shape_basic::Wall)
    {
        ret*=lightDef->transparency;
    }
    else if(basic_shape==df::tiletype_shape_basic::Floor || basic_shape==df::tiletype_shape_basic::Ramp || shape==df::tiletype_shape::STAIR_UP)
    {

        if(!lastLevel)
            ret*=lightDef->transparency.pow(1.0f/7.0f);
    }
    else if(shape==df::tiletype_shape::STAIR_DOWN || shape==df::tiletype_shape::STAIR_UPDOWN)
    {
        ret*=matStairCase;
    }
    if(d.bits.liquid_type == df::enums::tile_liquid::Water && d.bits.flow_size > 0)
    {
        ret *=matWater.transparency.pow((float)d.bits.flow_size/7.0f);
    }
    else if(d.bits.liquid_type == df::enums::tile_liquid::Magma && d.bits.flow_size > 0)
    {
        ret *=matLava.transparency.pow((float)d.bits.flow_size/7.0f);
    }
    return ret;
}
coord2d lightingEngineViewscreen::worldToViewportCoord(const coord2d& in,const rect2d& r,const coord2d& window2d)
{
    return in-window2d+r.first;
}

static size_t max_list_size = 100000; // Avoid iterating over huge lists
void lightingEngineViewscreen::doSun(const lightSource& sky,MapExtras::MapCache& map)
{
    //TODO fix this mess
    int window_x=*df::global::window_x;
    int window_y=*df::global::window_y;
    coord2d window2d(window_x,window_y);
    int window_z=*df::global::window_z;
    rect2d vp=getMapViewport();
    coord2d vpSize=rect_size(vp);
    rect2d blockVp;
    blockVp.first=window2d/16;
    blockVp.second=(window2d+vpSize)/16;
    blockVp.second.x=std::min(blockVp.second.x,(int16_t)df::global::world->map.x_count_block);
    blockVp.second.y=std::min(blockVp.second.y,(int16_t)df::global::world->map.y_count_block);
    //endof mess
    for(int blockX=blockVp.first.x;blockX<=blockVp.second.x;blockX++)
    for(int blockY=blockVp.first.y;blockY<=blockVp.second.y;blockY++)
    {
        rgbf cellArray[16][16];
        for(int block_x = 0; block_x < 16; block_x++)
        for(int block_y = 0; block_y < 16; block_y++)
            cellArray[block_x][block_y] = sky.power;

        int emptyCell=0;
        for(int z=window_z;z< df::global::world->map.z_count && emptyCell<256;z++)
        {
            MapExtras::Block* b=map.BlockAt(DFCoord(blockX,blockY,z));
            if(!b)
                continue;
            emptyCell=0;
            for(int block_x = 0; block_x < 16; block_x++)
            for(int block_y = 0; block_y < 16; block_y++)
            {
                rgbf& curCell=cellArray[block_x][block_y];
                curCell=propogateSun(b,block_x,block_y,curCell,z==window_z);
                if(curCell.dot(curCell)<0.003f)
                    emptyCell++;
            }
        }
        if(emptyCell==256)
            continue;
        for(int block_x = 0; block_x < 16; block_x++)
        for(int block_y = 0; block_y < 16; block_y++)
        {
            rgbf& curCell=cellArray[block_x][block_y];
            df::coord2d pos;
            pos.x = blockX*16+block_x;
            pos.y = blockY*16+block_y;
            pos=worldToViewportCoord(pos,vp,window2d);
            if(isInRect(pos,vp) && curCell.dot(curCell)>0.003f)
            {
                lightSource sun=lightSource(curCell,15);
                addLight(getIndex(pos.x,pos.y),sun);
            }
        }
    }
}
rgbf lightingEngineViewscreen::getSkyColor(float v)
{
    if(dayColors.size()<2)
    {
        v=abs(fmod(v+0.5,1)-0.5)*2;
        return rgbf(v,v,v);
    }
    else
    {
        float pos=v*(dayColors.size()-1);
        int pre=floor(pos);
        pos-=pre;
        if(pre==dayColors.size()-1)
            return dayColors[pre];
        return dayColors[pre]*(1-pos)+dayColors[pre+1]*pos;
    }
}
void lightingEngineViewscreen::doOcupancyAndLights()
{
    float daycol;
    if(dayHour<0)
    {
        int length=1200/daySpeed;
        daycol= (*df::global::cur_year_tick % length)/ (float)length;
    }
    else
        daycol= fmod(dayHour,24.0f)/24.0f; //1->12h 0->24h

    rgbf sky_col=getSkyColor(daycol);
    lightSource sky(sky_col, -1);//auto calculate best size

    MapExtras::MapCache cache;
    doSun(sky,cache);

    int window_x=*df::global::window_x;
    int window_y=*df::global::window_y;
    coord2d window2d(window_x,window_y);
    int window_z=*df::global::window_z;
    rect2d vp=getMapViewport();
    coord2d vpSize=rect_size(vp);
    rect2d blockVp;
    blockVp.first=coord2d(window_x,window_y)/16;
    blockVp.second=(window2d+vpSize)/16;
    blockVp.second.x=std::min(blockVp.second.x,(int16_t)df::global::world->map.x_count_block);
    blockVp.second.y=std::min(blockVp.second.y,(int16_t)df::global::world->map.y_count_block);

    for(int blockX=blockVp.first.x;blockX<=blockVp.second.x;blockX++)
    for(int blockY=blockVp.first.y;blockY<=blockVp.second.y;blockY++)
    {
        MapExtras::Block* b=cache.BlockAt(DFCoord(blockX,blockY,window_z));
        MapExtras::Block* bDown=cache.BlockAt(DFCoord(blockX,blockY,window_z-1));
        if(!b)
            continue; //empty blocks fixed by sun propagation

        for(int block_x = 0; block_x < 16; block_x++)
        for(int block_y = 0; block_y < 16; block_y++)
        {
            df::coord2d pos;
            pos.x = blockX*16+block_x;
            pos.y = blockY*16+block_y;
            df::coord2d gpos=pos;
            pos=worldToViewportCoord(pos,vp,window2d);
            if(!isInRect(pos,vp))
                continue;
            int tile=getIndex(pos.x,pos.y);
            rgbf& curCell=ocupancy[tile];
            curCell=matAmbience.transparency;


            df::tiletype type = b->tiletypeAt(gpos);
            df::tile_designation d = b->DesignationAt(gpos);
            if(d.bits.hidden )
            {
                curCell=rgbf(0,0,0);
                continue; // do not process hidden stuff, TODO other hidden stuff
            }
            //df::tile_occupancy o = b->OccupancyAt(gpos);
            df::tiletype_shape shape = ENUM_ATTR(tiletype,shape,type);
            bool is_wall=!ENUM_ATTR(tiletype_shape,passable_high,shape);
            bool is_floor=!ENUM_ATTR(tiletype_shape,passable_low,shape);
            df::tiletype_shape_basic basic_shape = ENUM_ATTR(tiletype_shape, basic_shape, shape);
            df::tiletype_material tileMat= ENUM_ATTR(tiletype,material,type);

            DFHack::t_matpair mat=b->staticMaterialAt(gpos);

            matLightDef* lightDef=getMaterialDef(mat.mat_type,mat.mat_index);
            if(!lightDef || !lightDef->isTransparent)
                lightDef=&matWall;
            if(shape==df::tiletype_shape::BROOK_BED )
            {
                curCell=rgbf(0,0,0);
            }
            else if(is_wall)
            {
                if(tileMat==df::tiletype_material::FROZEN_LIQUID)
                    applyMaterial(tile,matIce);
                else
                    applyMaterial(tile,*lightDef);
            }
            else if(!d.bits.liquid_type && d.bits.flow_size>0 )
            {
                applyMaterial(tile,matWater, (float)d.bits.flow_size/7.0f, (float)d.bits.flow_size/7.0f);
            }
            if(d.bits.liquid_type && d.bits.flow_size>0)
            {
                applyMaterial(tile,matLava,(float)d.bits.flow_size/7.0f,(float)d.bits.flow_size/7.0f);
            }
            else if(!is_floor)
            {
                if(bDown)
                {
                   df::tile_designation d2=bDown->DesignationAt(gpos);
                   if(d2.bits.liquid_type && d2.bits.flow_size>0)
                   {
                       applyMaterial(tile,matLava);
                   }
                }
            }


        }

        df::map_block* block=b->getRaw();
        if(!block)
            continue;
        //flows
        for(int i=0;i<block->flows.size();i++)
        {
            df::flow_info* f=block->flows[i];
            if(f && f->density>0 && (f->type==df::flow_type::Dragonfire || f->type==df::flow_type::Fire))
            {
                df::coord2d pos=f->pos;
                pos=worldToViewportCoord(pos,vp,window2d);
                int tile=getIndex(pos.x,pos.y);
                if(isInRect(pos,vp))
                {
                    rgbf fireColor;
                    if(f->density>60)
                    {
                        fireColor=rgbf(0.98f,0.91f,0.30f);
                    }
                    else if(f->density>30)
                    {
                        fireColor=rgbf(0.93f,0.16f,0.16f);
                    }
                    else
                    {
                        fireColor=rgbf(0.64f,0.0f,0.0f);
                    }
                    lightSource fire(fireColor,f->density/5);
                    addLight(tile,fire);
                }
            }
        }

        //blood and other goo
        for(int i=0;i<block->block_events.size();i++)
        {
            df::block_square_event* ev=block->block_events[i];
            df::block_square_event_type ev_type=ev->getType();
            if(ev_type==df::block_square_event_type::material_spatter)
            {
                df::block_square_event_material_spatterst* spatter=static_cast<df::block_square_event_material_spatterst*>(ev);
                matLightDef* m=getMaterialDef(spatter->mat_type,spatter->mat_index);
                if(!m)
                    continue;
                if(!m->isEmiting)
                    continue;
                for(int x=0;x<16;x++)
                for(int y=0;y<16;y++)
                {
                    df::coord2d pos;
                    pos.x = blockX*16+x;
                    pos.y = blockY*16+y;
                    int16_t amount=spatter->amount[x][y];
                    if(amount<=0)
                        continue;
                    pos=worldToViewportCoord(pos,vp,window2d);
                    if(isInRect(pos,vp))
                    {
                        addLight(getIndex(pos.x,pos.y),m->makeSource((float)amount/100));
                    }
                }
            }
        }
    }
    if(df::global::cursor->x>-30000)
    {
        int wx=df::global::cursor->x-window_x+vp.first.x;
        int wy=df::global::cursor->y-window_y+vp.first.y;
        int tile=getIndex(wx,wy);
        applyMaterial(tile,matCursor);
    }
    //citizen only emit light, if defined
    //or other creatures
    if(matCitizen.isEmiting || creatureDefs.size()>0)
    for (int i=0;i<df::global::world->units.active.size();++i)
    {
        df::unit *u = df::global::world->units.active[i];
        coord2d pos=worldToViewportCoord(coord2d(u->pos.x,u->pos.y),vp,window2d);
        if(u->pos.z==window_z && isInRect(pos,vp))
        {
            if (DFHack::Units::isCitizen(u) && !u->counters.unconscious)
                addLight(getIndex(pos.x,pos.y),matCitizen.makeSource());
            creatureLightDef *def=getCreatureDef(u);
            if(def && !u->flags1.bits.dead)
            {
                addLight(getIndex(pos.x,pos.y),def->light.makeSource());
            }
        }
    }
    //items
    if(itemDefs.size()>0)
    {
        std::vector<df::item*>& vec=df::global::world->items.other[items_other_id::IN_PLAY];
        for(size_t i=0;i<vec.size();i++)
        {
            df::item* curItem=vec[i];
            df::coord itemPos=DFHack::Items::getPosition(curItem);
            coord2d pos=worldToViewportCoord(itemPos,vp,window2d);
            itemLightDef* mat=0;
            if( itemPos.z==window_z && isInRect(pos,vp) && (mat=getItemDef(curItem)) )
            {
                if( ((mat->equiped || mat->haul ||mat->inBuilding ||mat->inContainer) && curItem->flags.bits.in_inventory)|| //TODO split this up
                    (mat->onGround && curItem->flags.bits.on_ground) )
                {
                    if(mat->light.isEmiting)
                        addLight(getIndex(pos.x,pos.y),mat->light.makeSource());
                    if(!mat->light.isTransparent)
                        addOclusion(getIndex(pos.x,pos.y),mat->light.transparency,1);
                }
            }
        }
    }

    //buildings
    for(size_t i = 0; i < df::global::world->buildings.all.size(); i++)
    {
        df::building *bld = df::global::world->buildings.all[i];

        if(window_z!=bld->z)
            continue;
        if(bld->getBuildStage()<bld->getMaxBuildStage()) //only work if fully built
            continue;

        df::coord2d p1(bld->x1,bld->y1);
        df::coord2d p2(bld->x2,bld->y2);
        p1=worldToViewportCoord(p1,vp,window2d);
        p2=worldToViewportCoord(p2,vp,window2d);
        if(isInRect(p1,vp)||isInRect(p2,vp))
        {

            int tile;
            if(isInRect(p1,vp))
                tile=getIndex(p1.x,p1.y); //TODO multitile buildings. How they would work?
            else
                tile=getIndex(p2.x,p2.y);
            df::building_type type = bld->getType();
            buildingLightDef* def=getBuildingDef(bld);
            if(!def)
                continue;
            if(type==df::enums::building_type::Door)
            {
                df::building_doorst* door=static_cast<df::building_doorst*>(bld);
                if(!door->door_flags.bits.closed)
                    continue;
            }
            else if(type==df::enums::building_type::Floodgate)
            {
                df::building_floodgatest* gate=static_cast<df::building_floodgatest*>(bld);
                if(!gate->gate_flags.bits.closed)
                    continue;
            }


            if(def->useMaterial)
            {
                matLightDef* mat=getMaterialDef(bld->mat_type,bld->mat_index);
                if(!mat)mat=&matWall;
                if(!def->poweredOnly || !bld->isUnpowered()) //not powered. Add occlusion only.
                {
                    if(def->light.isEmiting)
                    {
                        addLight(tile,def->light.makeSource(def->size));
                    }
                    else if(mat->isEmiting)
                    {
                        addLight(tile,mat->makeSource(def->size));
                    }
                }
                if(def->light.isTransparent)
                {
                    addOclusion(tile,def->light.transparency,def->size);
                }
                else
                {
                    addOclusion(tile,mat->transparency,def->size);
                }
            }
            else
            {
                if(!def->poweredOnly || !bld->isUnpowered())//not powered. Add occlusion only.
                    addOclusion(tile,def->light.transparency,def->size);
                else
                    applyMaterial(tile,def->light,def->size,def->thickness);
            }
        }
    }

}
rgbf lua_parseLightCell(lua_State* L)
{
    rgbf ret;

    lua_pushnumber(L,1);
    lua_gettable(L,-2);
    ret.r=lua_tonumber(L,-1);
    lua_pop(L,1);

    lua_pushnumber(L,2);
    lua_gettable(L,-2);
    ret.g=lua_tonumber(L,-1);
    lua_pop(L,1);

    lua_pushnumber(L,3);
    lua_gettable(L,-2);
    ret.b=lua_tonumber(L,-1);
    lua_pop(L,1);

    //Lua::GetOutput(L)->print("got cell(%f,%f,%f)\n",ret.r,ret.g,ret.b);
    return ret;
}
#define GETLUAFLAG(field,name) lua_getfield(L,-1,"flags");\
    if(lua_isnil(L,-1)){field=false;}\
    else{lua_getfield(L,-1,#name);field=lua_isnil(L,-1);lua_pop(L,1);}\
    lua_pop(L,1)

#define GETLUANUMBER(field,name) lua_getfield(L,-1,#name);\
    if(!lua_isnil(L,-1) && lua_isnumber(L,-1))field=lua_tonumber(L,-1);\
    lua_pop(L,1)
matLightDef lua_parseMatDef(lua_State* L)
{

    matLightDef ret;
    lua_getfield(L,-1,"tr");
    if(ret.isTransparent=!lua_isnil(L,-1))
    {
        ret.transparency=lua_parseLightCell(L);
    }
    lua_pop(L,1);

    lua_getfield(L,-1,"em");
    if(ret.isEmiting=!lua_isnil(L,-1))
    {
        ret.emitColor=lua_parseLightCell(L);
        lua_pop(L,1);
        lua_getfield(L,-1,"rad");
        if(lua_isnil(L,-1))
        {
            lua_pop(L,1);
            luaL_error(L,"Material has emittance but no radius");
        }
        else
            ret.radius=lua_tonumber(L,-1);
        lua_pop(L,1);
    }
    else
        lua_pop(L,1);
    GETLUAFLAG(ret.flicker,"flicker");
    return ret;
}
int lightingEngineViewscreen::parseMaterials(lua_State* L)
{
    auto engine= (lightingEngineViewscreen*)lua_touserdata(L, 1);
    engine->matDefs.clear();
    //color_ostream* os=Lua::GetOutput(L);
    Lua::StackUnwinder unwinder(L);
    lua_getfield(L,2,"materials");
    if(!lua_istable(L,-1))
    {
        luaL_error(L,"Materials table not found.");
        return 0;
    }
    lua_pushnil(L);
    while (lua_next(L, -2) != 0) {
        int type=lua_tonumber(L,-2);
        //os->print("Processing type:%d\n",type);
        lua_pushnil(L);
        while (lua_next(L, -2) != 0) {
            int index=lua_tonumber(L,-2);
            //os->print("\tProcessing index:%d\n",index);
            engine->matDefs[std::make_pair(type,index)]=lua_parseMatDef(L);

            lua_pop(L, 1);
        }
        lua_pop(L, 1);
    }
    return 0;
}
#define LOAD_SPECIAL(lua_name,class_name) \
    lua_getfield(L,-1,#lua_name);\
    if(!lua_isnil(L,-1))engine->class_name=lua_parseMatDef(L);\
    lua_pop(L,1)
int lightingEngineViewscreen::parseSpecial(lua_State* L)
{
    auto engine= (lightingEngineViewscreen*)lua_touserdata(L, 1);
    Lua::StackUnwinder unwinder(L);
    lua_getfield(L,2,"special");
    if(!lua_istable(L,-1))
    {
        luaL_error(L,"Special table not found.");
        return 0;
    }
    LOAD_SPECIAL(LAVA,matLava);
    LOAD_SPECIAL(WATER,matWater);
    LOAD_SPECIAL(FROZEN_LIQUID,matIce);
    LOAD_SPECIAL(AMBIENT,matAmbience);
    LOAD_SPECIAL(CURSOR,matCursor);
    LOAD_SPECIAL(CITIZEN,matCitizen);
    GETLUANUMBER(engine->levelDim,levelDim);
    GETLUANUMBER(engine->dayHour,dayHour);
    GETLUANUMBER(engine->daySpeed,daySpeed);
    GETLUANUMBER(engine->num_diffuse,diffusionCount);
    GETLUANUMBER(engine->adv_mode,advMode);
    lua_getfield(L,-1,"dayColors");
    if(lua_istable(L,-1))
    {
        engine->dayColors.clear();
        lua_pushnil(L);
        while (lua_next(L, -2) != 0) {
            engine->dayColors.push_back(lua_parseLightCell(L));
            lua_pop(L,1);
        }
        lua_pop(L,1);
    }
    return 0;
}
#undef LOAD_SPECIAL
int lightingEngineViewscreen::parseItems(lua_State* L)
{
    auto engine= (lightingEngineViewscreen*)lua_touserdata(L, 1);
    engine->itemDefs.clear();
    Lua::StackUnwinder unwinder(L);
    lua_getfield(L,2,"items");
    if(!lua_istable(L,-1))
    {
        luaL_error(L,"Items table not found.");
        return 0;
    }
    lua_pushnil(L);
    while (lua_next(L, -2) != 0) {
        if(!lua_istable(L,-1))
            luaL_error(L,"Broken item definitions.");
        lua_getfield(L,-1,"type");
        int type=lua_tonumber(L,-1);
        lua_pop(L,1);
        lua_getfield(L,-1,"subtype");
        int subtype=luaL_optinteger(L,-1,-1);
        lua_pop(L,1);
        itemLightDef item;
        lua_getfield(L,-1,"light");
        item.light=lua_parseMatDef(L);
        GETLUAFLAG(item.haul,"hauling");
        GETLUAFLAG(item.equiped,"equiped");
        GETLUAFLAG(item.inBuilding,"inBuilding");
        GETLUAFLAG(item.inContainer,"contained");
        GETLUAFLAG(item.onGround,"onGround");
        GETLUAFLAG(item.useMaterial,"useMaterial");
        engine->itemDefs[std::make_pair(type,subtype)]=item;
        lua_pop(L,2);
    }
    lua_pop(L,1);
    return 0;
}
int lightingEngineViewscreen::parseCreatures(lua_State* L)
{
    auto engine= (lightingEngineViewscreen*)lua_touserdata(L, 1);
    engine->creatureDefs.clear();
    Lua::StackUnwinder unwinder(L);
    lua_getfield(L,2,"creatures");
    if(!lua_istable(L,-1))
    {
        luaL_error(L,"Creatures table not found.");
        return 0;
    }
    lua_pushnil(L);
    while (lua_next(L, -2) != 0) {
        if(!lua_istable(L,-1))
            luaL_error(L,"Broken creature definitions.");
        lua_getfield(L,-1,"race");
        int race=lua_tonumber(L,-1);
        lua_pop(L,1);
        lua_getfield(L,-1,"caste");
        int caste=lua_tonumber(L,-1);
        lua_pop(L,1);
        creatureLightDef cr;
        lua_getfield(L,-1,"light");
        cr.light=lua_parseMatDef(L);
        engine->creatureDefs[std::make_pair(race,caste)]=cr;
        lua_pop(L,2);
    }
    lua_pop(L,1);
    return 0;
}
int lightingEngineViewscreen::parseBuildings(lua_State* L)
{
    auto engine= (lightingEngineViewscreen*)lua_touserdata(L, 1);
    engine->buildingDefs.clear();
    Lua::StackUnwinder unwinder(L);
    lua_getfield(L,2,"buildings");
    if(!lua_istable(L,-1))
    {
        luaL_error(L,"Buildings table not found.");
        return 0;
    }
    lua_pushnil(L);
    while (lua_next(L, -2) != 0) {
        int type=lua_tonumber(L,-2);
        if(!lua_istable(L,-1))
        {
            luaL_error(L,"Broken building definitions.");
        }
        //os->print("Processing type:%d\n",type);
        lua_pushnil(L);
        while (lua_next(L, -2) != 0) {
            int subtype=lua_tonumber(L,-2);
            //os->print("\tProcessing subtype:%d\n",index);
            lua_pushnil(L);
        while (lua_next(L, -2) != 0) {
            int custom=lua_tonumber(L,-2);
            //os->print("\tProcessing custom:%d\n",index);
            buildingLightDef current;
            current.light=lua_parseMatDef(L);
            engine->buildingDefs[std::make_tuple(type,subtype,custom)]=current;
            GETLUAFLAG(current.poweredOnly,"poweredOnly");
            GETLUAFLAG(current.useMaterial,"useMaterial");

            lua_getfield(L,-1,"size");
            current.size=luaL_optnumber(L,-1,1);
            lua_pop(L,1);

            lua_getfield(L,-1,"thickness");
            current.thickness=luaL_optnumber(L,-1,1);
            lua_pop(L,1);

            lua_pop(L, 1);
        }

            lua_pop(L, 1);
        }
        lua_pop(L, 1);
    }
    lua_pop(L,1);
    return 0;
}
void lightingEngineViewscreen::defaultSettings()
{
    matAmbience=matLightDef(rgbf(0.85f,0.85f,0.85f));
    matLava=matLightDef(rgbf(0.8f,0.2f,0.2f),rgbf(0.8f,0.2f,0.2f),5);
    matWater=matLightDef(rgbf(0.6f,0.6f,0.8f));
    matIce=matLightDef(rgbf(0.7f,0.7f,0.9f));
    matCursor=matLightDef(rgbf(0.96f,0.84f,0.03f),11);
    matCursor.flicker=true;
    matWall=matLightDef(rgbf(0,0,0));
    matCitizen=matLightDef(rgbf(0.8f,0.8f,0.9f),6);
    levelDim=0.2f;
    dayHour=-1;
    daySpeed=1;
    adv_mode=0;
    num_diffuse=0;
    dayColors.push_back(rgbf(0,0,0));
    dayColors.push_back(rgbf(1,1,1));
    dayColors.push_back(rgbf(0,0,0));
}
void lightingEngineViewscreen::loadSettings()
{
    std::string rawFolder;
    if(df::global::world->cur_savegame.save_dir!="")
    {
        rawFolder= "data/save/" + (df::global::world->cur_savegame.save_dir) + "/raw/";
    }
    else
    {
        rawFolder= "raw/";
    }
    const std::string settingsfile=rawFolder+"rendermax.lua";

    CoreSuspender lock;
    color_ostream_proxy out(Core::getInstance().getConsole());

    lua_State* s=DFHack::Lua::Core::State;
    lua_newtable(s);
    int env=lua_gettop(s);
    try{
        int ret=luaL_loadfile(s,settingsfile.c_str());
        if(ret==LUA_ERRFILE)
        {
            out.printerr("File not found:%s\n",settingsfile.c_str());
            lua_pop(s,1);
        }
        else if(ret==LUA_ERRSYNTAX)
        {
            out.printerr("Syntax error:\n\t%s\n",lua_tostring(s,-1));
        }
        else
        {
            lua_pushvalue(s,env);

            if(Lua::SafeCall(out,s,1,0))
            {
                lua_pushcfunction(s, parseMaterials);
                lua_pushlightuserdata(s, this);
                lua_pushvalue(s,env);
                Lua::SafeCall(out,s,2,0);
                out.print("%d materials loaded\n",matDefs.size());

                lua_pushcfunction(s, parseSpecial);
                lua_pushlightuserdata(s, this);
                lua_pushvalue(s,env);
                Lua::SafeCall(out,s,2,0);
                out.print("%d day light colors loaded\n",dayColors.size());

                lua_pushcfunction(s, parseBuildings);
                lua_pushlightuserdata(s, this);
                lua_pushvalue(s,env);
                Lua::SafeCall(out,s,2,0);
                out.print("%d buildings loaded\n",buildingDefs.size());

                lua_pushcfunction(s, parseCreatures);
                lua_pushlightuserdata(s, this);
                lua_pushvalue(s,env);
                Lua::SafeCall(out,s,2,0);
                out.print("%d creatures loaded\n",creatureDefs.size());

                lua_pushcfunction(s, parseItems);
                lua_pushlightuserdata(s, this);
                lua_pushvalue(s,env);
                Lua::SafeCall(out,s,2,0);
                out.print("%d items loaded\n",itemDefs.size());
            }

        }
    }
    catch(std::exception& e)
    {
        out.printerr("%s",e.what());
    }
    lua_pop(s,1);
}
#undef GETLUAFLAG
#undef GETLUANUMBER
/*
 *      Threading stuff
 */
lightThread::lightThread( lightThreadDispatch& dispatch ):dispatch(dispatch),isDone(false),myThread(0)
{

}
lightThread::~lightThread()
{
    delete myThread;
}

void lightThread::run()
{
    while(!isDone)
    {
        //TODO: get area to process, and then process (by rounds): 1. occlusions, 2.sun, 3.lights(could be difficult, units/items etc...)
        {//wait for occlusion (and lights) to be ready
            tthread::lock_guard<tthread::mutex> guard(dispatch.occlusionMutex);
            if(!dispatch.occlusionReady)
            dispatch.occlusionDone.wait(dispatch.occlusionMutex);//wait for work
            if(dispatch.unprocessed.size()==0 || !dispatch.occlusionReady) //spurious wake-up
                continue;
            if(dispatch.occlusion.size()!=canvas.size()) //oh no somebody resized stuff
                canvas.resize(dispatch.occlusion.size());
        }


        { //get my rectangle (any will do)
            tthread::lock_guard<tthread::mutex> guard(dispatch.unprocessedMutex);
            if (dispatch.unprocessed.size()==0)
            {
                //wtf?? why?!
                continue;
            }
            myRect=dispatch.unprocessed.top();
            dispatch.unprocessed.pop();
            if (dispatch.unprocessed.size()==0)
            {
                dispatch.occlusionReady=false;
            }

        }
        work();
        {
            tthread::lock_guard<tthread::mutex> guard(dispatch.writeLock);
            combine();//write it back
            dispatch.writeCount++;
        }
        dispatch.writesDone.notify_one();//tell about it to the dispatch.
    }
}

void lightThread::work()
{
    canvas.assign(canvas.size(),rgbf(0,0,0));
    for(int i=myRect.first.x;i<myRect.second.x;i++)
    for(int j=myRect.first.y;j<myRect.second.y;j++)
    {
        doLight(i,j);
    }
}

void lightThread::combine()
{
    for(int i=0;i<canvas.size();i++)
    {
        rgbf& c=dispatch.lightMap[i];
        c=blend(c,canvas[i]);
    }
}


rgbf lightThread::lightUpCell(rgbf power,int dx,int dy,int tx,int ty)
{
    int h=dispatch.getH();
    if(isInRect(coord2d(tx,ty),dispatch.viewPort))
    {
        size_t tile=tx*h+ty;
        int dsq=dx*dx+dy*dy;
        float dt=1;
        if(dsq == 1)//array lookup might be faster still
            dt=1;
        else if(dsq == 2)
            dt = RootTwo;
        else if(dsq == 0)
            dt = 0;
        else
            dt=sqrt((float)dsq);
        rgbf& v=dispatch.occlusion[tile];
        lightSource& ls=dispatch.lights[tile];
        bool wallhack=false;
        if(v.r+v.g+v.b==0)
            wallhack=true;

        if (dsq>0 && !wallhack)
        {
            power*=v.pow(dt);
        }
        if(ls.radius>0 && dsq>0)
        {
            if(power<=ls.power) //quit early if hitting another (stronger) lightsource
                return rgbf();
        }

        rgbf oldCol=canvas[tile];
        rgbf ncol=blendMax(power,oldCol);
        canvas[tile]=ncol;

        if(wallhack)
            return rgbf();


        return power;
    }
    else
        return rgbf();
}
void lightThread::doRay(const rgbf& power,int cx,int cy,int tx,int ty,int num_diffuse)
{
    using namespace std::placeholders;
    plotLineDiffuse(cx,cy,tx,ty,power,num_diffuse,std::bind(&lightThread::lightUpCell,this,_1,_2,_3,_4,_5));
}

void lightThread::doLight( int x,int y )
{
    using namespace std::placeholders;
    lightSource& csource=dispatch.lights[x*dispatch.getH()+y];
    int num_diffuse=dispatch.num_diffusion;
    if(csource.radius>0)
    {
        rgbf power=csource.power;
        int radius =csource.radius;
        if(csource.flicker)
        {
            float flicker=(rand()/(float)RAND_MAX)/2.0f+0.5f;
            radius*=flicker;
            power=power*flicker;
        }
        rgbf surrounds;
        lightUpCell( power, 0, 0,x, y); //light up the source itself
        for(int i=-1;i<2;i++)
            for(int j=-1;j<2;j++)
                if(i!=0||j!=0)
                    surrounds += lightUpCell( power, i, j,x+i, y+j); //and this is wall hack (so that walls look nice)
        if(surrounds.dot(surrounds)>0.00001f) //if we needed to light up the suroundings, then raycast
        {

            plotSquare(x,y,radius,
                std::bind(&lightThread::doRay,this,power,x,y,_1,_2,num_diffuse));
        }
    }
}
void lightThreadDispatch::signalDoneOcclusion()
{
    {
        tthread::lock_guard<tthread::mutex> guardWrite(writeLock);
        writeCount=0;
    }
    tthread::lock_guard<tthread::mutex> guard1(occlusionMutex);
    tthread::lock_guard<tthread::mutex> guard2(unprocessedMutex);
    while(!unprocessed.empty())
        unprocessed.pop();
    viewPort=getMapViewport();
    int threadCount=threadPool.size();
    int w=viewPort.second.x-viewPort.first.x;
    int slicew=w/threadCount;
    for(int i=0;i<threadCount;i++)
    {
        rect2d area=viewPort;
        area.first.x=viewPort.first.x+i*slicew;
        if(i==threadCount-1)
            area.second.x=viewPort.second.x; //fix, when area is even number or sth.
        else
            area.second.x=viewPort.first.x+(i+1)*slicew;
        unprocessed.push(area);
    }
    occlusionReady=true;
    occlusionDone.notify_all();
}

lightThreadDispatch::lightThreadDispatch( lightingEngineViewscreen* p ):parent(p),lights(parent->lights),occlusion(parent->ocupancy),num_diffusion(parent->num_diffuse),
    lightMap(parent->lightMap),writeCount(0),occlusionReady(false)
{

}

void lightThreadDispatch::shutdown()
{
    for(int i=0;i<threadPool.size();i++)
    {
        threadPool[i]->isDone=true;

    }
    occlusionDone.notify_all();//if stuck signal that you are done with stuff.
    for(int i=0;i<threadPool.size();i++)
    {
        threadPool[i]->myThread->join();
    }
    threadPool.clear();
}

int lightThreadDispatch::getW()
{
    return parent->getW();
}

int lightThreadDispatch::getH()
{
    return parent->getH();
}
void threadStub(void * arg)
{
    if(arg)
        ((lightThread*)arg)->run();
}
void lightThreadDispatch::start(int count)
{
    for(int i=0;i<count;i++)
    {
        std::unique_ptr<lightThread> nthread(new lightThread(*this));
        nthread->myThread=new tthread::thread(&threadStub,nthread.get());
        threadPool.push_back(std::move(nthread));
    }
}

void lightThreadDispatch::waitForWrites()
{
    tthread::lock_guard<tthread::mutex> guard(writeLock);
    while(threadPool.size()>writeCount)//missed it somehow already.
    {
        writesDone.wait(writeLock); //if not, wait a bit
    }
}

lightThreadDispatch::~lightThreadDispatch()
{
    shutdown();
}
