diff --git a/plugins/rendermax/renderer_light.cpp b/plugins/rendermax/renderer_light.cpp index 4509c463d..4df4ea9bf 100644 --- a/plugins/rendermax/renderer_light.cpp +++ b/plugins/rendermax/renderer_light.cpp @@ -1179,6 +1179,7 @@ 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 guard(dispatch.occlusionMutex); if(!dispatch.occlusionReady) @@ -1243,7 +1244,7 @@ rgbf lightThread::lightUpCell(rgbf power,int dx,int dy,int tx,int ty) size_t tile=tx*h+ty; int dsq=dx*dx+dy*dy; float dt=1; - if(dsq == 1) + if(dsq == 1)//array lookup might be faster still dt=1; else if(dsq == 2) dt = RootTwo; @@ -1263,10 +1264,10 @@ rgbf lightThread::lightUpCell(rgbf power,int dx,int dy,int tx,int ty) } if(ls.radius>0 && dsq>0) { - if(power<=ls.power) + if(power<=ls.power) //quit early if hitting another (stronger) lightsource return rgbf(); } - //float dt=sqrt(dsq); + rgbf oldCol=canvas[tile]; rgbf ncol=blendMax(power,oldCol); canvas[tile]=ncol; @@ -1302,12 +1303,12 @@ void lightThread::doLight( int x,int y ) power=power*flicker; } rgbf surrounds; - lightUpCell( power, 0, 0,x, y); + 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); - if(surrounds.dot(surrounds)>0.00001f) + 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)); diff --git a/plugins/rendermax/renderer_light.hpp b/plugins/rendermax/renderer_light.hpp index 75fb5ab6c..eadd497e6 100644 --- a/plugins/rendermax/renderer_light.hpp +++ b/plugins/rendermax/renderer_light.hpp @@ -44,6 +44,30 @@ namespace std bool isInRect(const df::coord2d& pos,const DFHack::rect2d& rect); struct renderer_light : public renderer_wrap { private: + float light_adaptation; + rgbf adapt_to_light(const rgbf& light) + { + const float influence=0.0001; + const float max_adapt=1; + const float min_adapt=0; + float intensity=(light.r+light.g+light.b)/3.0; + light_adaptation=intensity*influence+light_adaptation*(1-influence); + float delta=light_adaptation-intensity; + + rgbf ret; + ret.r=light.r-delta; + ret.g=light.g-delta; + ret.b=light.b-delta; + return ret; + //if light_adaptation/intensity~1 then draw 1,1,1 (i.e. totally adapted) + /* + 1. adapted -> 1,1,1 (full bright everything okay) delta=0 multiplier=? + 2. light adapted, real=dark -> darker delta>0 multiplier<1 + 3. dark adapted, real=light -> lighter delta<0 multiplier>1 + */ + //if light_adaptation/intensity!=0 then draw + + } void colorizeTile(int x,int y) { const int tile = x*(df::global::gps->dimy) + y; @@ -51,8 +75,9 @@ private: float *fg = p->fg + tile * 4 * 6; float *bg = p->bg + tile * 4 * 6; float *tex = p->tex + tile * 2 * 6; - rgbf light=lightGrid[tile]; - for (int i = 0; i < 6; i++) { + rgbf light=lightGrid[tile];//for light adaptation: rgbf light=adapt_to_light(lightGrid[tile]); + + for (int i = 0; i < 6; i++) { //oh how sse would do wonders here, or shaders... *(fg++) *= light.r; *(fg++) *= light.g; *(fg++) *= light.b; @@ -73,10 +98,11 @@ private: { reinitLightGrid(df::global::gps->dimy,df::global::gps->dimx); } + public: tthread::fast_mutex dataMutex; std::vector lightGrid; - renderer_light(renderer* parent):renderer_wrap(parent) + renderer_light(renderer* parent):renderer_wrap(parent),light_adaptation(1) { reinitLightGrid(); }