{

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;

{

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;

}

{

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);

{

reinit();

defaultSettings();

int numTreads=tthread::thread::hardware_concurrency();

if(numTreads==0)numTreads=1;

threading.start(numTreads);

{

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);

{

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);

{

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 */

}

{

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 ;

{

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 ;

{

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;

}

{

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();

}

{

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();

{

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);

{

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);

}

}

{

power=blend(power,other.power);

radius=std::max(other.radius,radius);//hack... but who cares

{

bool wasLight=lights[tileId].radius>0;

lights[tileId].combine(light);

if(light.flicker)

lights[tileId].flicker=true;

return wasLight;

{

if(thickness > 0.999 && thickness < 1.001)

ocupancy[tileId]*=c;

else

ocupancy[tileId]*=(c.pow(thickness));

{

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);

{

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;

{

int nId=getPlantNumber(id);

if(nId>0)

{

map[nId]=v;

}

{

if(mat.isTransparent)

{

addOclusion(tileId,mat.transparency,thickness);

}

else

ocupancy[tileId]=rgbf(0,0,0);

if(mat.isEmiting)

addLight(tileId,mat.makeSource(size));

{

matLightDef* m=getMaterialDef(matType,matIndex);

if(m)

{

applyMaterial(tileId,*m,size,thickness);

return true;

}

else if(def)

{

applyMaterial(tileId,*def,size,thickness);

}

return false;

{

//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;

{

//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);

}

}

}

{

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;

}

{

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 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;

{

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;

{

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;