Do not compile, deleting stuff...

1 files changed, 5 insertions, 185 deletions

diff --git a/src/engine/lightmap.cpp b/src/engine/lightmap.cpp
index 959782e..b8759c9 100644
--- a/src/engine/lightmap.cpp
+++ b/src/engine/lightmap.cpp
@@ -78,55 +78,12 @@ VARR(lightprecision, 1, 32, 1024);
 VARR(lighterror, 1, 8, 16);
 VARR(bumperror, 1, 3, 16);
 VARR(lightlod, 0, 0, 10);
-bvec ambientcolor(0x19, 0x19, 0x19), skylightcolor(0, 0, 0);
+bvec ambientcolor(36, 24, 12);
 HVARFR(ambient, 1, 0x191919, 0xFFFFFF,
 {
 	if(ambient <= 255) ambient |= (ambient<<8) | (ambient<<16);
 	ambientcolor = bvec((ambient>>16)&0xFF, (ambient>>8)&0xFF, ambient&0xFF);
 });
-HVARFR(skylight, 0, 0, 0xFFFFFF,
-{
-	if(skylight <= 255) skylight |= (skylight<<8) | (skylight<<16);
-	skylightcolor = bvec((skylight>>16)&0xFF, (skylight>>8)&0xFF, skylight&0xFF);
-});
-
-extern void setupsunlight();
-bvec sunlightcolor(0, 0, 0);
-HVARFR(sunlight, 0, 0, 0xFFFFFF,
-{
-	if(sunlight <= 255) sunlight |= (sunlight<<8) | (sunlight<<16);
-	sunlightcolor = bvec((sunlight>>16)&0xFF, (sunlight>>8)&0xFF, sunlight&0xFF);
-	setupsunlight();
-});
-FVARFR(sunlightscale, 0, 1, 16, setupsunlight());
-vec sunlightdir(0, 0, 1);
-extern void setsunlightdir();
-VARFR(sunlightyaw, 0, 0, 360, setsunlightdir());
-VARFR(sunlightpitch, -90, 90, 90, setsunlightdir());
-
-void setsunlightdir()
-{
-	sunlightdir = vec(sunlightyaw*RAD, sunlightpitch*RAD);
-	loopk(3) if(fabs(sunlightdir[k]) < 1e-5f) sunlightdir[k] = 0;
-	sunlightdir.normalize();
-	setupsunlight();
-}
-
-entity sunlightent;
-void setupsunlight()
-{
-	memclear(sunlightent);
-	sunlightent.type = ET_LIGHT;
-	sunlightent.attr1 = 0;
-	sunlightent.attr2 = int(sunlightcolor.x*sunlightscale);
-	sunlightent.attr3 = int(sunlightcolor.y*sunlightscale);
-	sunlightent.attr4 = int(sunlightcolor.z*sunlightscale);
-	float dist = min(min(sunlightdir.x ? 1/fabs(sunlightdir.x) : 1e16f, sunlightdir.y ? 1/fabs(sunlightdir.y) : 1e16f), sunlightdir.z ? 1/fabs(sunlightdir.z) : 1e16f);
-	sunlightent.o = vec(sunlightdir).mul(dist*worldsize).add(vec(worldsize/2, worldsize/2, worldsize/2));
-}
-
-VARR(skytexturelight, 0, 1, 1);
-extern int useskytexture;
 
 static const surfaceinfo brightsurfaces[6] =
 {
@@ -566,29 +523,6 @@ static uint generatelumel(lightmapworker *w, const float tolerance, uint lightma
 		g += intensity * float(light.attr3);
 		b += intensity * float(light.attr4);
 	}
-	if(sunlight)
-	{
-		float angle = sunlightdir.dot(normal);
-		if(angle > 0 &&
-		   (!lmshadows ||
-			shadowray(w->shadowraycache, vec(sunlightdir).mul(tolerance).add(target), sunlightdir, 1e16f, RAY_SHADOW | (lmshadows > 1 ? RAY_ALPHAPOLY : 0) | (skytexturelight ? RAY_SKIPSKY | (useskytexture ? RAY_SKYTEX : 0) : 0)) > 1e15f))
-		{
-			float intensity;
-			switch(w->type&LM_TYPE)
-			{
-				case LM_BUMPMAP0:
-					intensity = 1;
-					avgray.add(sunlightdir);
-					break;
-				default:
-					intensity = angle;
-					break;
-			}
-			r += intensity * (sunlightcolor.x*sunlightscale);
-			g += intensity * (sunlightcolor.y*sunlightscale);
-			b += intensity * (sunlightcolor.z*sunlightscale);
-		}
-	}
 	switch(w->type&LM_TYPE)
 	{
 		case LM_BUMPMAP0:
@@ -624,56 +558,6 @@ static bool lumelsample(const vec &sample, int aasample, int stride)
 	return false;
 }
 
-static void calcskylight(lightmapworker *w, const vec &o, const vec &normal, float tolerance, uchar *skylight, int flags = RAY_ALPHAPOLY, extentity *t = NULL)
-{
-	static const vec rays[17] =
-	{
-		vec(cosf(21*RAD)*cosf(50*RAD), sinf(21*RAD)*cosf(50*RAD), sinf(50*RAD)),
-		vec(cosf(111*RAD)*cosf(50*RAD), sinf(111*RAD)*cosf(50*RAD), sinf(50*RAD)),
-		vec(cosf(201*RAD)*cosf(50*RAD), sinf(201*RAD)*cosf(50*RAD), sinf(50*RAD)),
-		vec(cosf(291*RAD)*cosf(50*RAD), sinf(291*RAD)*cosf(50*RAD), sinf(50*RAD)),
-
-		vec(cosf(66*RAD)*cosf(70*RAD), sinf(66*RAD)*cosf(70*RAD), sinf(70*RAD)),
-		vec(cosf(156*RAD)*cosf(70*RAD), sinf(156*RAD)*cosf(70*RAD), sinf(70*RAD)),
-		vec(cosf(246*RAD)*cosf(70*RAD), sinf(246*RAD)*cosf(70*RAD), sinf(70*RAD)),
-		vec(cosf(336*RAD)*cosf(70*RAD), sinf(336*RAD)*cosf(70*RAD), sinf(70*RAD)),
-
-		vec(0, 0, 1),
-
-		vec(cosf(43*RAD)*cosf(60*RAD), sinf(43*RAD)*cosf(60*RAD), sinf(60*RAD)),
-		vec(cosf(133*RAD)*cosf(60*RAD), sinf(133*RAD)*cosf(60*RAD), sinf(60*RAD)),
-		vec(cosf(223*RAD)*cosf(60*RAD), sinf(223*RAD)*cosf(60*RAD), sinf(60*RAD)),
-		vec(cosf(313*RAD)*cosf(60*RAD), sinf(313*RAD)*cosf(60*RAD), sinf(60*RAD)),
-
-		vec(cosf(88*RAD)*cosf(80*RAD), sinf(88*RAD)*cosf(80*RAD), sinf(80*RAD)),
-		vec(cosf(178*RAD)*cosf(80*RAD), sinf(178*RAD)*cosf(80*RAD), sinf(80*RAD)),
-		vec(cosf(268*RAD)*cosf(80*RAD), sinf(268*RAD)*cosf(80*RAD), sinf(80*RAD)),
-		vec(cosf(358*RAD)*cosf(80*RAD), sinf(358*RAD)*cosf(80*RAD), sinf(80*RAD)),
-
-	};
-	flags |= RAY_SHADOW;
-	if(skytexturelight) flags |= RAY_SKIPSKY | (useskytexture ? RAY_SKYTEX : 0);
-	int hit = 0;
-	if(w) loopi(17)
-	{
-		if(normal.dot(rays[i])>=0 && shadowray(w->shadowraycache, vec(rays[i]).mul(tolerance).add(o), rays[i], 1e16f, flags, t)>1e15f) hit++;
-	}
-	else loopi(17)
-	{
-		if(normal.dot(rays[i])>=0 && shadowray(vec(rays[i]).mul(tolerance).add(o), rays[i], 1e16f, flags, t)>1e15f) hit++;
-	}
-
-	loopk(3) skylight[k] = uchar(ambientcolor[k] + (max(skylightcolor[k], ambientcolor[k]) - ambientcolor[k])*hit/17.0f);
-}
-
-static inline bool hasskylight()
-{
-	return skylightcolor[0]>ambientcolor[0] || skylightcolor[1]>ambientcolor[1] || skylightcolor[2]>ambientcolor[2];
-}
-
-VARR(blurlms, 0, 0, 2);
-VARR(blurskylight, 0, 0, 2);
-
 static inline void generatealpha(lightmapworker *w, float tolerance, const vec &pos, uchar &alpha)
 {
 	alpha = lookupblendmap(w->blendmapcache, pos);
@@ -770,14 +654,6 @@ static bool generatelightmap(lightmapworker *w, float lpu, const lerpvert *lv, i
 			float t = EDGE_TOLERANCE(x, y) * tolerance;
 			vec u = x < sidex ? vec(xstep1).mul(x).add(vec(ystep1).mul(y)).add(origin1) : vec(xstep2).mul(x).add(vec(ystep2).mul(y)).add(origin2);
 			lightused |= generatelumel(w, t, 0, w->lights, u, vec(normal).normalize(), *sample, x, y);
-			if(hasskylight())
-			{
-				if((w->type&LM_TYPE)==LM_BUMPMAP0 || !adaptivesample || sample->x<skylightcolor[0] || sample->y<skylightcolor[1] || sample->z<skylightcolor[2])
-					calcskylight(w, u, normal, t, skylight, lmshadows > 1 ? RAY_ALPHAPOLY : 0);
-				else loopk(3) skylight[k] = max(skylightcolor[k], ambientcolor[k]);
-			}
-			else loopk(3) skylight[k] = ambientcolor[k];
-			if(w->type&LM_ALPHA) generatealpha(w, t, u, skylight[3]);
 			sample += aasample;
 		}
 		sample += aasample;
@@ -849,16 +725,10 @@ static bool generatelightmap(lightmapworker *w, float lpu, const lerpvert *lv, i
 
 static int finishlightmap(lightmapworker *w)
 {
-	if(hasskylight() && blurskylight && (w->w>1 || w->h>1))
-	{
-		blurtexture(blurskylight, w->bpp, w->w, w->h, w->blur, w->ambient);
-		swap(w->blur, w->ambient);
-	}
 	vec *sample = w->colordata;
 	int aasample = min(1 << lmaa, 4), stride = aasample*(w->w+1);
 	float weight = 1.0f / (1.0f + 4.0f*lmaa),
 		  cweight = weight * (lmaa == 3 ? 5.0f : 1.0f);
-	uchar *skylight = w->ambient;
 	vec *ray = w->raydata;
 	uchar *dstcolor = blurlms && (w->w > 1 || w->h > 1) ? w->blur : w->colorbuf;
 	uchar mincolor[4] = { 255, 255, 255, 255 }, maxcolor[4] = { 0, 0, 0, 0 };
@@ -887,7 +757,7 @@ static int finishlightmap(lightmapworker *w)
 			int r = int(center.x*cweight + l.x*weight),
 				g = int(center.y*cweight + l.y*weight),
 				b = int(center.z*cweight + l.z*weight),
-				ar = skylight[0], ag = skylight[1], ab = skylight[2];
+				ar = w->ambient[0], ag = w->ambient[1], ab = w->ambient[2];
 			dstcolor[0] = max(ar, r);
 			dstcolor[1] = max(ag, g);
 			dstcolor[2] = max(ab, b);
@@ -898,7 +768,7 @@ static int finishlightmap(lightmapworker *w)
 			}
 			if(w->type&LM_ALPHA)
 			{
-				dstcolor[3] = skylight[3];
+				dstcolor[3] = ambientcolor[3];
 				mincolor[3] = min(mincolor[3], dstcolor[3]);
 				maxcolor[3] = max(maxcolor[3], dstcolor[3]);
 			}
@@ -907,8 +777,6 @@ static int finishlightmap(lightmapworker *w)
 				if(ray->iszero()) dstray[0] = bvec(128, 128, 255);
 				else
 				{
-					// bias the normals towards the amount of ambient/skylight in the lumel
-					// this is necessary to prevent the light values in shaders from dropping too far below the skylight (to the ambient) if N.L is small
 					ray->normalize();
 					int l = max(r, max(g, b)), a = max(ar, max(ag, ab));
 					ray->mul(max(l-a, 0));
@@ -924,7 +792,6 @@ static int finishlightmap(lightmapworker *w)
 				dstray++;
 			}
 			dstcolor += w->bpp;
-			skylight += w->bpp;
 		}
 		sample += aasample;
 	}
@@ -1153,7 +1020,7 @@ static bool findlights(lightmapworker *w, int cx, int cy, int cz, int size, cons
 		}
 	}
 	if(vslot.layer && (setblendmaporigin(w->blendmapcache, ivec(cx, cy, cz), size) || slot.layermask)) return true;
-	return w->lights.length() || hasskylight() || sunlight;
+	return w->lights.length();
 }
 
 static int packlightmaps(lightmapworker *w = NULL)
@@ -2401,33 +2268,6 @@ void initlights()
 	shouldlightents = true;
 }
 
-static inline void fastskylight(const vec &o, float tolerance, uchar *skylight, int flags = RAY_ALPHAPOLY, extentity *t = NULL, bool fast = false)
-{
-	flags |= RAY_SHADOW;
-	if(skytexturelight) flags |= RAY_SKIPSKY | (useskytexture ? RAY_SKYTEX : 0);
-	if(fast)
-	{
-		static const vec ray(0, 0, 1);
-		if(shadowray(vec(ray).mul(tolerance).add(o), ray, 1e16f, flags, t)>1e15f)
-			memcpy(skylight, skylightcolor.v, 3);
-		else memcpy(skylight, ambientcolor.v, 3);
-	}
-	else
-	{
-		static const vec rays[5] =
-		{
-			vec(cosf(66*RAD)*cosf(65*RAD), sinf(66*RAD)*cosf(65*RAD), sinf(65*RAD)),
-			vec(cosf(156*RAD)*cosf(65*RAD), sinf(156*RAD)*cosf(65*RAD), sinf(65*RAD)),
-			vec(cosf(246*RAD)*cosf(65*RAD), sinf(246*RAD)*cosf(65*RAD), sinf(65*RAD)),
-			vec(cosf(336*RAD)*cosf(65*RAD), sinf(336*RAD)*cosf(65*RAD), sinf(65*RAD)),
-			vec(0, 0, 1),
-		};
-		int hit = 0;
-		loopi(5) if(shadowray(vec(rays[i]).mul(tolerance).add(o), rays[i], 1e16f, flags, t)>1e15f) hit++;
-		loopk(3) skylight[k] = uchar(ambientcolor[k] + (max(skylightcolor[k], ambientcolor[k]) - ambientcolor[k])*hit/5.0f);
-	}
-}
-
 void lightreaching(const vec &target, vec &color, vec &dir, bool fast, extentity *t, float ambient)
 {
 	if((fullbright && editmode) || lightmaps.empty())
@@ -2471,37 +2311,17 @@ void lightreaching(const vec &target, vec &color, vec &dir, bool fast, extentity
 			intensity *= spotatten;
 		}
 
-		//if(target==player->o)
-		//{
-		//	conoutf(CON_DEBUG, "%d - %f %f", i, intensity, mag);
-		//}
-
 		vec lightcol = vec(e.attr2, e.attr3, e.attr4).mul(1.0f/255);
 		color.add(vec(lightcol).mul(intensity));
 		dir.add(vec(ray).mul(-intensity*lightcol.x*lightcol.y*lightcol.z));
 	}
-	if(sunlight && shadowray(target, sunlightdir, 1e16f, RAY_SHADOW | RAY_POLY | (skytexturelight ? RAY_SKIPSKY | (useskytexture ? RAY_SKYTEX : 0) : 0), t) > 1e15f)
-	{
-		vec lightcol = vec(sunlightcolor.x, sunlightcolor.y, sunlightcolor.z).mul(sunlightscale/255);
-		color.add(lightcol);
-		dir.add(vec(sunlightdir).mul(lightcol.x*lightcol.y*lightcol.z));
-	}
-	if(hasskylight())
-	{
-		uchar skylight[3];
-		if(t) calcskylight(NULL, target, vec(0, 0, 0), 0.5f, skylight, RAY_POLY, t);
-		else fastskylight(target, 0.5f, skylight, RAY_POLY, t, fast);
-		loopk(3) color[k] = min(1.5f, max(max(skylight[k]/255.0f, ambient), color[k]));
-	}
-	else loopk(3) color[k] = min(1.5f, max(max(ambientcolor[k]/255.0f, ambient), color[k]));
+	loopk(3) color[k] = min(1.5f, max(max(ambientcolor[k]/255.0f, ambient), color[k]));
 	if(dir.iszero()) dir = vec(0, 0, 1);
 	else dir.normalize();
 }
 
 entity *brightestlight(const vec &target, const vec &dir)
 {
-	if(sunlight && sunlightdir.dot(dir) > 0 && shadowray(target, sunlightdir, 1e16f, RAY_SHADOW | RAY_POLY | (skytexturelight ? RAY_SKIPSKY | (useskytexture ? RAY_SKYTEX : 0) : 0)) > 1e15f)
-		return &sunlightent;
 	const vector<extentity *> &ents = entities::getents();
 	const vector<int> &lights = checklightcache(int(target.x), int(target.y));
 	extentity *brightest = NULL;