X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=model_shared.c;h=7697fa6ee1ce5ff7d49cfeb80a99de6619df8674;hb=66d1df20a5ed5ff954d7bf9db2db23cbe304281a;hp=721e92e64fc591964f0d44b8c87b2ae58def5f41;hpb=1b22fcde9020388846613bf64bd9bab6eac25b27;p=xonotic%2Fdarkplaces.git

diff --git a/model_shared.c b/model_shared.c
index 721e92e6..7697fa6e 100644
--- a/model_shared.c
+++ b/model_shared.c
@@ -28,9 +28,15 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "polygon.h"
 
 cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0", "mipmaps model skins so they render faster in the distance and do not display noise artifacts, can cause discoloration of skins if they contain undesirable border colors"};
-cvar_t mod_generatelightmaps_unitspersample = {CVAR_SAVE, "mod_generatelightmaps_unitspersample", "16", "lightmap resolution"};
+cvar_t mod_generatelightmaps_unitspersample = {CVAR_SAVE, "mod_generatelightmaps_unitspersample", "8", "lightmap resolution"};
 cvar_t mod_generatelightmaps_borderpixels = {CVAR_SAVE, "mod_generatelightmaps_borderpixels", "2", "extra space around polygons to prevent sampling artifacts"};
 cvar_t mod_generatelightmaps_texturesize = {CVAR_SAVE, "mod_generatelightmaps_texturesize", "1024", "size of lightmap textures"};
+cvar_t mod_generatelightmaps_lightmapsamples = {CVAR_SAVE, "mod_generatelightmaps_lightmapsamples", "16", "number of shadow tests done per lightmap pixel"};
+cvar_t mod_generatelightmaps_vertexsamples = {CVAR_SAVE, "mod_generatelightmaps_vertexsamples", "16", "number of shadow tests done per vertex"};
+cvar_t mod_generatelightmaps_gridsamples = {CVAR_SAVE, "mod_generatelightmaps_gridsamples", "64", "number of shadow tests done per lightgrid cell"};
+cvar_t mod_generatelightmaps_lightmapradius = {CVAR_SAVE, "mod_generatelightmaps_lightmapradius", "16", "sampling area around each lightmap pixel"};
+cvar_t mod_generatelightmaps_vertexradius = {CVAR_SAVE, "mod_generatelightmaps_vertexradius", "16", "sampling area around each vertex"};
+cvar_t mod_generatelightmaps_gridradius = {CVAR_SAVE, "mod_generatelightmaps_gridradius", "64", "sampling area around each lightgrid cell center"};
 
 dp_model_t *loadmodel;
 
@@ -157,6 +163,14 @@ void Mod_Init (void)
 	Cvar_RegisterVariable(&mod_generatelightmaps_unitspersample);
 	Cvar_RegisterVariable(&mod_generatelightmaps_borderpixels);
 	Cvar_RegisterVariable(&mod_generatelightmaps_texturesize);
+
+	Cvar_RegisterVariable(&mod_generatelightmaps_lightmapsamples);
+	Cvar_RegisterVariable(&mod_generatelightmaps_vertexsamples);
+	Cvar_RegisterVariable(&mod_generatelightmaps_gridsamples);
+	Cvar_RegisterVariable(&mod_generatelightmaps_lightmapradius);
+	Cvar_RegisterVariable(&mod_generatelightmaps_vertexradius);
+	Cvar_RegisterVariable(&mod_generatelightmaps_gridradius);
+
 	Cmd_AddCommand ("modellist", Mod_Print, "prints a list of loaded models");
 	Cmd_AddCommand ("modelprecache", Mod_Precache, "load a model");
 	Cmd_AddCommand ("modeldecompile", Mod_Decompile_f, "exports a model in several formats for editing purposes");
@@ -641,12 +655,13 @@ void Mod_BuildTriangleNeighbors(int *neighbors, const int *elements, int numtria
 		int element[2];
 	}
 	edgehashentry_t;
-	edgehashentry_t *edgehash[TRIANGLEEDGEHASH], *edgehashentries, edgehashentriesbuffer[TRIANGLEEDGEHASH*3], *hash;
+	static edgehashentry_t *edgehash[TRIANGLEEDGEHASH];
+	edgehashentry_t *edgehashentries, *hash;
+	if (!numtriangles)
+		return;
 	memset(edgehash, 0, sizeof(edgehash));
-	edgehashentries = edgehashentriesbuffer;
 	// if there are too many triangles for the stack array, allocate larger buffer
-	if (numtriangles > TRIANGLEEDGEHASH)
-		edgehashentries = (edgehashentry_t *)Mem_Alloc(tempmempool, numtriangles * 3 * sizeof(edgehashentry_t));
+	edgehashentries = (edgehashentry_t *)Mem_Alloc(tempmempool, numtriangles * 3 * sizeof(edgehashentry_t));
 	// find neighboring triangles
 	for (i = 0, e = elements, n = neighbors;i < numtriangles;i++, e += 3, n += 3)
 	{
@@ -695,8 +710,7 @@ void Mod_BuildTriangleNeighbors(int *neighbors, const int *elements, int numtria
 		CL_KeepaliveMessage(false);
 	}
 	// free the allocated buffer
-	if (edgehashentries != edgehashentriesbuffer)
-		Mem_Free(edgehashentries);
+	Mem_Free(edgehashentries);
 }
 #else
 // very slow but simple way
@@ -1132,7 +1146,7 @@ shadowmesh_t *Mod_ShadowMesh_Begin(mempool_t *mempool, int maxverts, int maxtria
 
 static void Mod_ShadowMesh_CreateVBOs(shadowmesh_t *mesh)
 {
-	if (!gl_support_arb_vertex_buffer_object)
+	if (!vid.support.arb_vertex_buffer_object)
 		return;
 
 	// element buffer is easy because it's just one array
@@ -2054,6 +2068,9 @@ qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qbool
 		texflagsmask &= ~TEXF_COMPRESS;
 	texture->specularscalemod = 1; // unless later loaded from the shader
 	texture->specularpowermod = 1; // unless later loaded from the shader
+	// WHEN ADDING DEFAULTS HERE, REMEMBER TO SYNC TO SHADER LOADING ABOVE
+	// HERE, AND Q1BSP LOADING
+	// JUST GREP FOR "specularscalemod = 1".
 
 	if (shader)
 	{
@@ -2224,10 +2241,9 @@ nothing                GL_ZERO GL_ONE
 		{
 			if (fallback)
 			{
-				qboolean has_alpha;
-				if ((texture->skinframes[0] = R_SkinFrame_LoadExternal_CheckAlpha(texture->name, defaulttexflags, false, &has_alpha)))
+				if ((texture->skinframes[0] = R_SkinFrame_LoadExternal(texture->name, defaulttexflags, false)))
 				{
-					if(has_alpha && (defaulttexflags & TEXF_ALPHA))
+					if(texture->skinframes[0]->hasalpha)
 						texture->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
 				}
 				else
@@ -2479,7 +2495,7 @@ static void Mod_BuildVBOs(void)
 		}
 	}
 
-	if (!gl_support_arb_vertex_buffer_object)
+	if (!vid.support.arb_vertex_buffer_object)
 		return;
 
 	// element buffer is easy because it's just one array
@@ -2929,7 +2945,7 @@ void Mod_AllocLightmap_Init(mod_alloclightmap_state_t *state, int width, int hei
 	state->width = width;
 	state->height = height;
 	state->currentY = 0;
-	state->rows = Mem_Alloc(tempmempool, state->height * sizeof(*state->rows));
+	state->rows = Mem_Alloc(loadmodel->mempool, state->height * sizeof(*state->rows));
 	for (y = 0;y < state->height;y++)
 	{
 		state->rows[y].currentX = 0;
@@ -3027,34 +3043,320 @@ typedef struct lightmaptriangle_s
 	// 2D modelspace to lightmap coordinate scale
 	float lmscale[2];
 	float vertex[3][3];
+	float mins[3];
+	float maxs[3];
 }
 lightmaptriangle_t;
 
+typedef struct lightmaplight_s
+{
+	float origin[3];
+	float radius;
+	float iradius;
+	float radius2;
+	float color[3];
+	svbsp_t svbsp;
+}
+lightmaplight_t;
+
 lightmaptriangle_t *mod_generatelightmaps_lightmaptriangles;
 
-static void Mod_GenerateLightmaps_Sample(const float *pos, const float *normal, float *vertex_color, unsigned char *lm_bgr, unsigned char *lm_dir)
+#define MAX_LIGHTMAPSAMPLES 64
+static int mod_generatelightmaps_numoffsets[3];
+static float mod_generatelightmaps_offsets[3][MAX_LIGHTMAPSAMPLES][3];
+
+static int mod_generatelightmaps_numlights;
+static lightmaplight_t *mod_generatelightmaps_lightinfo;
+
+static void Mod_GenerateLightmaps_CreateLights_ComputeSVBSP_InsertSurfaces(const dp_model_t *model, svbsp_t *svbsp, const float *mins, const float *maxs)
 {
-	
-/*
-	if (mod_generatelightmaps_maxsamples <= mod_generatelightmaps_numsamples)
-	{
-		lightmapsample_t *oldsamples = mod_generatelightmaps_samples;
-		mod_generatelightmaps_maxsamples = max(65536, mod_generatelightmaps_maxsamples * 2);
-		
-		
-	}
-	sample = &mod_generatelightmaps_samples[mod_generatelightmaps_numsamples++];
-	memset(sample, 0, sizeof(*sample));
-	sample->pos[0] = pos[0];
-	sample->pos[1] = pos[1];
-	sample->pos[2] = pos[2];
-	sample->normal[0] = normal[0];
-	sample->normal[1] = normal[1];
-	sample->normal[2] = normal[2];
-	sample->vertex_color = vertex_color;
-	sample->lm_bgr = lm_bgr;
-	sample->lm_dir = lm_dir;
-	*/
+	int surfaceindex;
+	int triangleindex;
+	const msurface_t *surface;
+	const float *vertex3f = model->surfmesh.data_vertex3f;
+	const int *element3i = model->surfmesh.data_element3i;
+	const int *e;
+	double v2[3][3];
+	for (surfaceindex = 0, surface = model->data_surfaces;surfaceindex < model->nummodelsurfaces;surfaceindex++, surface++)
+	{
+		if (!BoxesOverlap(surface->mins, surface->maxs, mins, maxs))
+			continue;
+		if (R_GetCurrentTexture(surface->texture)->currentmaterialflags & MATERIALFLAG_NOSHADOW)
+			continue;
+		for (triangleindex = 0, e = element3i + 3*surface->num_firsttriangle;triangleindex < surface->num_triangles;triangleindex++, e += 3)
+		{
+			VectorCopy(vertex3f + 3*e[0], v2[0]);
+			VectorCopy(vertex3f + 3*e[1], v2[1]);
+			VectorCopy(vertex3f + 3*e[2], v2[2]);
+			SVBSP_AddPolygon(svbsp, 3, v2[0], true, NULL, NULL, 0);
+		}
+	}
+}
+
+static void Mod_GenerateLightmaps_CreateLights_ComputeSVBSP(dp_model_t *model, lightmaplight_t *lightinfo)
+{
+	int maxnodes = 1<<14;
+	svbsp_node_t *nodes;
+	double origin[3];
+	float mins[3];
+	float maxs[3];
+	svbsp_t svbsp;
+	VectorSet(mins, lightinfo->origin[0] - lightinfo->radius, lightinfo->origin[1] - lightinfo->radius, lightinfo->origin[2] - lightinfo->radius);
+	VectorSet(maxs, lightinfo->origin[0] + lightinfo->radius, lightinfo->origin[1] + lightinfo->radius, lightinfo->origin[2] + lightinfo->radius);
+	VectorCopy(lightinfo->origin, origin);
+	nodes = Mem_Alloc(tempmempool, maxnodes * sizeof(*nodes));
+	for (;;)
+	{
+		SVBSP_Init(&svbsp, origin, maxnodes, nodes);
+		Mod_GenerateLightmaps_CreateLights_ComputeSVBSP_InsertSurfaces(model, &svbsp, mins, maxs);
+		if (svbsp.ranoutofnodes)
+		{
+			maxnodes *= 2;
+			if (maxnodes >= 1<<22)
+			{
+				Mem_Free(nodes);
+				return;
+			}
+			Mem_Free(nodes);
+			nodes = Mem_Alloc(tempmempool, maxnodes * sizeof(*nodes));
+		}
+		else
+			break;
+	}
+	if (svbsp.numnodes > 0)
+	{
+		svbsp.nodes = Mem_Alloc(tempmempool, svbsp.numnodes * sizeof(*nodes));
+		memcpy(svbsp.nodes, nodes, svbsp.numnodes * sizeof(*nodes));
+		lightinfo->svbsp = svbsp;
+	}
+	Mem_Free(nodes);
+}
+
+extern int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color);
+static void Mod_GenerateLightmaps_CreateLights(dp_model_t *model)
+{
+	int index;
+	int result;
+	lightmaplight_t *lightinfo;
+	float origin[3];
+	float radius;
+	float color[3];
+	mod_generatelightmaps_numlights = 0;
+	for (index = 0;;index++)
+	{
+		result = R_Shadow_GetRTLightInfo(index, origin, &radius, color);
+		if (result < 0)
+			break;
+		if (result > 0)
+			mod_generatelightmaps_numlights++;
+	}
+	if (mod_generatelightmaps_numlights > 0)
+	{
+		mod_generatelightmaps_lightinfo = Mem_Alloc(tempmempool, mod_generatelightmaps_numlights * sizeof(*mod_generatelightmaps_lightinfo));
+		lightinfo = mod_generatelightmaps_lightinfo;
+		for (index = 0;;index++)
+		{
+			result = R_Shadow_GetRTLightInfo(index, lightinfo->origin, &lightinfo->radius, lightinfo->color);
+			if (result < 0)
+				break;
+			if (result > 0)
+				lightinfo++;
+		}
+	}
+	for (index = 0, lightinfo = mod_generatelightmaps_lightinfo;index < mod_generatelightmaps_numlights;index++, lightinfo++)
+	{
+		lightinfo->iradius = 1.0f / lightinfo->radius;
+		lightinfo->radius2 = lightinfo->radius * lightinfo->radius;
+		// TODO: compute svbsp
+		Mod_GenerateLightmaps_CreateLights_ComputeSVBSP(model, lightinfo);
+	}
+}
+
+static void Mod_GenerateLightmaps_DestroyLights(dp_model_t *model)
+{
+	int i;
+	if (mod_generatelightmaps_lightinfo)
+	{
+		for (i = 0;i < mod_generatelightmaps_numlights;i++)
+			if (mod_generatelightmaps_lightinfo[i].svbsp.nodes)
+				Mem_Free(mod_generatelightmaps_lightinfo[i].svbsp.nodes);
+		Mem_Free(mod_generatelightmaps_lightinfo);
+	}
+	mod_generatelightmaps_lightinfo = NULL;
+	mod_generatelightmaps_numlights = 0;
+}
+
+static qboolean Mod_GenerateLightmaps_SamplePoint_SVBSP(const svbsp_t *svbsp, const float *pos)
+{
+	const svbsp_node_t *node;
+	const svbsp_node_t *nodes = svbsp->nodes;
+	int num = 0;
+	while (num >= 0)
+	{
+		node = nodes + num;
+		num = node->children[DotProduct(node->plane, pos) < node->plane[3]];
+	}
+	return num == -1; // true if empty, false if solid (shadowed)
+}
+
+extern cvar_t r_shadow_lightattenuationdividebias;
+extern cvar_t r_shadow_lightattenuationlinearscale;
+static void Mod_GenerateLightmaps_SamplePoint(const float *pos, const float *normal, float *sample, int numoffsets, const float *offsets)
+{
+	int i;
+	float relativepoint[3];
+	float color[3];
+	float offsetpos[3];
+	float dist;
+	float dist2;
+	float intensity;
+	int offsetindex;
+	int hits;
+	int tests;
+	const lightmaplight_t *lightinfo;
+	trace_t trace;
+	for (i = 0;i < 5*3;i++)
+		sample[i] = 0.0f;
+	for (i = 0, lightinfo = mod_generatelightmaps_lightinfo;i < mod_generatelightmaps_numlights;i++, lightinfo++)
+	{
+		//R_SampleRTLights(pos, sample, numoffsets, offsets);
+		VectorSubtract(lightinfo->origin, pos, relativepoint);
+		// don't accept light from behind a surface, it causes bad shading
+		if (normal && DotProduct(relativepoint, normal) <= 0)
+			continue;
+		dist2 = VectorLength2(relativepoint);
+		if (dist2 >= lightinfo->radius2)
+			continue;
+		dist = sqrt(dist2) * lightinfo->iradius;
+		intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
+		if (intensity <= 0)
+			continue;
+		if (cl.worldmodel && cl.worldmodel->TraceLine && numoffsets > 0)
+		{
+			hits = 0;
+			tests = 1;
+			if (Mod_GenerateLightmaps_SamplePoint_SVBSP(&lightinfo->svbsp, pos))
+				hits++;
+			for (offsetindex = 1;offsetindex < numoffsets;offsetindex++)
+			{
+				VectorAdd(pos, offsets + 3*offsetindex, offsetpos);
+				if (!normal)
+				{
+					// for light grid we'd better check visibility of the offset point
+					cl.worldmodel->TraceLine(cl.worldmodel, NULL, NULL, &trace, pos, offsetpos, SUPERCONTENTS_VISBLOCKERMASK);
+					if (trace.fraction < 1)
+						VectorLerp(pos, trace.fraction, offsetpos, offsetpos);
+				}
+				tests++;
+				if (Mod_GenerateLightmaps_SamplePoint_SVBSP(&lightinfo->svbsp, offsetpos))
+					hits++;
+			}
+			if (!hits)
+				continue;
+			// scale intensity according to how many rays succeeded
+			// we know one test is valid, half of the rest will fail...
+			//if (normal && tests > 1)
+			//	intensity *= (tests - 1.0f) / tests;
+			intensity *= (float)hits / tests;
+		}
+		// scale down intensity to add to both ambient and diffuse
+		//intensity *= 0.5f;
+		VectorNormalize(relativepoint);
+		VectorScale(lightinfo->color, intensity, color);
+		VectorMA(sample    , 0.5f            , color, sample    );
+		VectorMA(sample + 3, relativepoint[0], color, sample + 3);
+		VectorMA(sample + 6, relativepoint[1], color, sample + 6);
+		VectorMA(sample + 9, relativepoint[2], color, sample + 9);
+		// calculate a weighted average light direction as well
+		intensity *= VectorLength(color);
+		VectorMA(sample + 12, intensity, relativepoint, sample + 12);
+	}
+}
+
+static void Mod_GenerateLightmaps_LightmapSample(const float *pos, const float *normal, unsigned char *lm_bgr, unsigned char *lm_dir)
+{
+	float sample[5*3];
+	float color[3];
+	float dir[3];
+	float f;
+	Mod_GenerateLightmaps_SamplePoint(pos, normal, sample, mod_generatelightmaps_numoffsets[0], mod_generatelightmaps_offsets[0][0]);
+	//VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
+	VectorCopy(sample + 12, dir);
+	VectorNormalize(dir);
+	//VectorAdd(dir, normal, dir);
+	//VectorNormalize(dir);
+	f = DotProduct(dir, normal);
+	f = max(0, f) * 255.0f;
+	VectorScale(sample, f, color);
+	//VectorCopy(normal, dir);
+	VectorSet(dir, (dir[0]+1.0f)*127.5f, (dir[1]+1.0f)*127.5f, (dir[2]+1.0f)*127.5f);
+	lm_bgr[0] = (unsigned char)bound(0.0f, color[2], 255.0f);
+	lm_bgr[1] = (unsigned char)bound(0.0f, color[1], 255.0f);
+	lm_bgr[2] = (unsigned char)bound(0.0f, color[0], 255.0f);
+	lm_bgr[3] = 255;
+	lm_dir[0] = (unsigned char)dir[2];
+	lm_dir[1] = (unsigned char)dir[1];
+	lm_dir[2] = (unsigned char)dir[0];
+	lm_dir[3] = 255;
+}
+
+static void Mod_GenerateLightmaps_VertexSample(const float *pos, const float *normal, float *vertex_color)
+{
+	float sample[5*3];
+	Mod_GenerateLightmaps_SamplePoint(pos, normal, sample, mod_generatelightmaps_numoffsets[1], mod_generatelightmaps_offsets[1][0]);
+	VectorCopy(sample, vertex_color);
+}
+
+static void Mod_GenerateLightmaps_GridSample(const float *pos, q3dlightgrid_t *s)
+{
+	float sample[5*3];
+	float ambient[3];
+	float diffuse[3];
+	float dir[3];
+	Mod_GenerateLightmaps_SamplePoint(pos, NULL, sample, mod_generatelightmaps_numoffsets[2], mod_generatelightmaps_offsets[2][0]);
+	// calculate the direction we'll use to reduce the sample to a directional light source
+	VectorCopy(sample + 12, dir);
+	//VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
+	VectorNormalize(dir);
+	// extract the diffuse color along the chosen direction and scale it
+	diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]) * 127.5f;
+	diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]) * 127.5f;
+	diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]) * 127.5f;
+	// scale the ambient from 0-2 to 0-255 and subtract some of diffuse
+	VectorScale(sample, 127.5f, ambient);
+	VectorMA(ambient, -0.333f, diffuse, ambient);
+	// encode to the grid format
+	s->ambientrgb[0] = (unsigned char)bound(0.0f, ambient[0], 255.0f);
+	s->ambientrgb[1] = (unsigned char)bound(0.0f, ambient[1], 255.0f);
+	s->ambientrgb[2] = (unsigned char)bound(0.0f, ambient[2], 255.0f);
+	s->diffusergb[0] = (unsigned char)bound(0.0f, diffuse[0], 255.0f);
+	s->diffusergb[1] = (unsigned char)bound(0.0f, diffuse[1], 255.0f);
+	s->diffusergb[2] = (unsigned char)bound(0.0f, diffuse[2], 255.0f);
+	if (dir[2] >= 0.99f) {s->diffusepitch = 0;s->diffuseyaw = 0;}
+	else if (dir[2] <= -0.99f) {s->diffusepitch = 128;s->diffuseyaw = 0;}
+	else {s->diffusepitch = (unsigned char)(acos(dir[2]) * (127.5f/M_PI));s->diffuseyaw = (unsigned char)(atan2(dir[1], dir[0]) * (127.5f/M_PI));}
+}
+
+static void Mod_GenerateLightmaps_InitSampleOffsets(dp_model_t *model)
+{
+	float radius[3];
+	float temp[3];
+	int i, j;
+	memset(mod_generatelightmaps_offsets, 0, sizeof(mod_generatelightmaps_offsets));
+	mod_generatelightmaps_numoffsets[0] = min(MAX_LIGHTMAPSAMPLES, mod_generatelightmaps_lightmapsamples.integer);
+	mod_generatelightmaps_numoffsets[1] = min(MAX_LIGHTMAPSAMPLES, mod_generatelightmaps_vertexsamples.integer);
+	mod_generatelightmaps_numoffsets[2] = min(MAX_LIGHTMAPSAMPLES, mod_generatelightmaps_gridsamples.integer);
+	radius[0] = mod_generatelightmaps_lightmapradius.value;
+	radius[1] = mod_generatelightmaps_vertexradius.value;
+	radius[2] = mod_generatelightmaps_gridradius.value;
+	for (i = 0;i < 3;i++)
+	{
+		for (j = 1;j < mod_generatelightmaps_numoffsets[i];j++)
+		{
+			VectorRandom(temp);
+			VectorScale(temp, radius[i], mod_generatelightmaps_offsets[i][j]);
+		}
+	}
 }
 
 static void Mod_GenerateLightmaps_DestroyLightmaps(dp_model_t *model)
@@ -3176,6 +3478,8 @@ static void Mod_GenerateLightmaps_CreateTriangleInformation(dp_model_t *model)
 	msurface_t *surface;
 	int surfaceindex;
 	int i;
+	int axis;
+	float normal[3];
 	const int *e;
 	lightmaptriangle_t *triangle;
 	// generate lightmap triangle structs
@@ -3192,65 +3496,35 @@ static void Mod_GenerateLightmaps_CreateTriangleInformation(dp_model_t *model)
 			VectorCopy(model->surfmesh.data_vertex3f + 3*e[i*3+0], triangle->vertex[0]);
 			VectorCopy(model->surfmesh.data_vertex3f + 3*e[i*3+1], triangle->vertex[1]);
 			VectorCopy(model->surfmesh.data_vertex3f + 3*e[i*3+2], triangle->vertex[2]);
-		}
-	}
-}
-
-#if 0
-float lmprojection[3][3][3] =
-{
-	{{0, 1, 0}, {0, 0, 1}, {1, 0, 0}},
-	{{1, 0, 0}, {0, 0, 1}, {0, 1, 0}},
-	{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}},
-};
-#endif
-
-static void Mod_GenerateLightmaps_ClassifyTriangles(dp_model_t *model)
-{
-	msurface_t *surface;
-	int surfaceindex;
-	int i;
-	int axis;
-	float mins[3];
-	float maxs[3];
-	float aabbsize[3];
-	const int *e;
-	lightmaptriangle_t *triangle;
-
-	for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
-	{
-		surface = model->data_surfaces + surfaceindex;
-		e = model->surfmesh.data_element3i + surface->num_firsttriangle*3;
-		for (i = 0;i < surface->num_triangles;i++)
-		{
-			triangle = &mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle+i];
 			// calculate bounds of triangle
-			mins[0] = min(triangle->vertex[0][0], min(triangle->vertex[1][0], triangle->vertex[2][0]));
-			mins[1] = min(triangle->vertex[0][1], min(triangle->vertex[1][1], triangle->vertex[2][1]));
-			mins[2] = min(triangle->vertex[0][2], min(triangle->vertex[1][2], triangle->vertex[2][2]));
-			maxs[0] = max(triangle->vertex[0][0], max(triangle->vertex[1][0], triangle->vertex[2][0]));
-			maxs[1] = max(triangle->vertex[0][1], max(triangle->vertex[1][1], triangle->vertex[2][1]));
-			maxs[2] = max(triangle->vertex[0][2], max(triangle->vertex[1][2], triangle->vertex[2][2]));
-			// pick an axial projection based on the shortest dimension of the
-			// axially aligned bounding box, this is almost equivalent to
-			// calculating a triangle normal and classifying its primary axis.
-			//
-			// one difference is that this method can pick a workable
-			// projection axis even for a degenerate triangle whose only shape
-			// is a line (where the chosen projection will always map the line
-			// to non-zero coordinates in texture space)
-			VectorSubtract(maxs, mins, aabbsize);
+			triangle->mins[0] = min(triangle->vertex[0][0], min(triangle->vertex[1][0], triangle->vertex[2][0]));
+			triangle->mins[1] = min(triangle->vertex[0][1], min(triangle->vertex[1][1], triangle->vertex[2][1]));
+			triangle->mins[2] = min(triangle->vertex[0][2], min(triangle->vertex[1][2], triangle->vertex[2][2]));
+			triangle->maxs[0] = max(triangle->vertex[0][0], max(triangle->vertex[1][0], triangle->vertex[2][0]));
+			triangle->maxs[1] = max(triangle->vertex[0][1], max(triangle->vertex[1][1], triangle->vertex[2][1]));
+			triangle->maxs[2] = max(triangle->vertex[0][2], max(triangle->vertex[1][2], triangle->vertex[2][2]));
+			// pick an axial projection based on the triangle normal
+			TriangleNormal(triangle->vertex[0], triangle->vertex[1], triangle->vertex[2], normal);
 			axis = 0;
-			if (aabbsize[1] < aabbsize[axis])
+			if (fabs(normal[1]) > fabs(normal[axis]))
 				axis = 1;
-			if (aabbsize[2] < aabbsize[axis])
+			if (fabs(normal[2]) > fabs(normal[axis]))
 				axis = 2;
 			triangle->axis = axis;
 		}
 	}
 }
 
-static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
+static void Mod_GenerateLightmaps_DestroyTriangleInformation(dp_model_t *model)
+{
+	if (mod_generatelightmaps_lightmaptriangles)
+		Mem_Free(mod_generatelightmaps_lightmaptriangles);
+	mod_generatelightmaps_lightmaptriangles = NULL;
+}
+
+float lmaxis[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+
+static void Mod_GenerateLightmaps_CreateLightmaps(dp_model_t *model)
 {
 	msurface_t *surface;
 	int surfaceindex;
@@ -3261,18 +3535,19 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 	int k;
 	int x;
 	int y;
+	int axis;
+	int axis1;
+	int axis2;
 	int retry;
 	int pixeloffset;
-	int row_numpoints;
-	int column_numpoints;
-	float f;
-	float row_plane[3];
-	float column_plane[3];
 	float trianglenormal[3];
-	float clipbuf[5][8][3];
 	float samplecenter[3];
 	float samplenormal[3];
-	float mins[3];
+	float temp[3];
+	float lmiscale[2];
+	float slopex;
+	float slopey;
+	float slopebase;
 	float lmscalepixels;
 	float lmmins;
 	float lmmaxs;
@@ -3291,7 +3566,7 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 		model->texturepool = R_AllocTexturePool();
 	lm_basescalepixels = 1.0f / max(0.0001f, mod_generatelightmaps_unitspersample.value);
 	lm_borderpixels = mod_generatelightmaps_borderpixels.integer;
-	lm_texturesize = bound(lm_borderpixels*2+1, 64, gl_max_texture_size);
+	lm_texturesize = bound(lm_borderpixels*2+1, 64, (int)vid.maxtexturesize_2d);
 	lm_maxpixels = lm_texturesize-(lm_borderpixels*2+1);
 	Mod_AllocLightmap_Init(&lmstate, lm_texturesize, lm_texturesize);
 	lightmapnumber = 0;
@@ -3320,8 +3595,8 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 				{
 					if (j == triangle->axis)
 						continue;
-					lmmins = floor(mins[j]*lmscalepixels)-lm_borderpixels;
-					lmmaxs = floor(mins[j]*lmscalepixels)+lm_borderpixels;
+					lmmins = floor(triangle->mins[j]*lmscalepixels)-lm_borderpixels;
+					lmmaxs = floor(triangle->maxs[j]*lmscalepixels)+lm_borderpixels;
 					triangle->lmsize[k] = (int)(lmmaxs-lmmins);
 					triangle->lmbase[k] = lmmins/lmscalepixels;
 					triangle->lmscale[k] = lmscalepixels;
@@ -3335,7 +3610,7 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 				break;
 			// if we haven't maxed out the lightmap size yet, we retry the
 			// entire surface batch...
-			if (lm_texturesize * 2 <= min(mod_generatelightmaps_texturesize.integer, gl_max_texture_size))
+			if (lm_texturesize * 2 <= min(mod_generatelightmaps_texturesize.integer, (int)vid.maxtexturesize_2d))
 			{
 				lm_texturesize *= 2;
 				surfaceindex = -1;
@@ -3354,15 +3629,17 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 			Mod_AllocLightmap_Reset(&lmstate);
 		}
 	}
+	lightmapnumber++;
 	Mod_AllocLightmap_Free(&lmstate);
 
 	// now together lightmap textures
+	model->brushq3.deluxemapping_modelspace = true;
+	model->brushq3.deluxemapping = true;
 	model->brushq3.num_mergedlightmaps = lightmapnumber;
 	model->brushq3.data_lightmaps = Mem_Alloc(model->mempool, model->brushq3.num_mergedlightmaps * sizeof(rtexture_t *));
 	model->brushq3.data_deluxemaps = Mem_Alloc(model->mempool, model->brushq3.num_mergedlightmaps * sizeof(rtexture_t *));
 	lightmappixels = Mem_Alloc(tempmempool, model->brushq3.num_mergedlightmaps * lm_texturesize * lm_texturesize * 4);
 	deluxemappixels = Mem_Alloc(tempmempool, model->brushq3.num_mergedlightmaps * lm_texturesize * lm_texturesize * 4);
-	lightmapnumber = 0;
 	for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
 	{
 		surface = model->data_surfaces + surfaceindex;
@@ -3370,10 +3647,32 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 		for (i = 0;i < surface->num_triangles;i++)
 		{
 			triangle = &mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle+i];
-			VectorClear(row_plane);
-			VectorClear(column_plane);
-			row_plane[triangle->axis] = 1.0f;
-			column_plane[!triangle->axis] = 1.0f;
+			TriangleNormal(triangle->vertex[0], triangle->vertex[1], triangle->vertex[2], trianglenormal);
+			VectorNormalize(trianglenormal);
+			VectorCopy(trianglenormal, samplenormal); // FIXME: this is supposed to be interpolated per pixel from vertices
+			axis = triangle->axis;
+			axis1 = axis == 0 ? 1 : 0;
+			axis2 = axis == 2 ? 1 : 2;
+			lmiscale[0] = 1.0f / triangle->lmscale[0];
+			lmiscale[1] = 1.0f / triangle->lmscale[1];
+			if (trianglenormal[axis] < 0)
+				VectorNegate(trianglenormal, trianglenormal);
+			CrossProduct(lmaxis[axis2], trianglenormal, temp);slopex = temp[axis] / temp[axis1];
+			CrossProduct(lmaxis[axis1], trianglenormal, temp);slopey = temp[axis] / temp[axis2];
+			slopebase = triangle->vertex[0][axis] - triangle->vertex[0][axis1]*slopex - triangle->vertex[0][axis2]*slopey;
+			for (j = 0;j < 3;j++)
+			{
+				float *t2f = model->surfmesh.data_texcoordlightmap2f + e[i*3+j]*2;
+				t2f[0] = ((triangle->vertex[j][axis1] - triangle->lmbase[0]) * triangle->lmscale[0] + triangle->lmoffset[0]) / lm_texturesize;
+				t2f[1] = ((triangle->vertex[j][axis2] - triangle->lmbase[1]) * triangle->lmscale[1] + triangle->lmoffset[1]) / lm_texturesize;
+#if 0
+				samplecenter[axis1] = (t2f[0]*lm_texturesize-triangle->lmoffset[0])*lmiscale[0] + triangle->lmbase[0];
+				samplecenter[axis2] = (t2f[1]*lm_texturesize-triangle->lmoffset[1])*lmiscale[1] + triangle->lmbase[1];
+				samplecenter[axis] = samplecenter[axis1]*slopex + samplecenter[axis2]*slopey + slopebase;
+				Con_Printf("%f:%f %f:%f %f:%f = %f %f\n", triangle->vertex[j][axis1], samplecenter[axis1], triangle->vertex[j][axis2], samplecenter[axis2], triangle->vertex[j][axis], samplecenter[axis], t2f[0], t2f[1]);
+#endif
+			}
+
 #if 0
 			switch (axis)
 			{
@@ -3424,37 +3723,16 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 			Matrix4x4_FromVectors(&backmatrix, forward, left, up, origin);
 #endif
 #define LM_DIST_EPSILON (1.0f / 32.0f)
-			TriangleNormal(triangle->vertex[0], triangle->vertex[1], triangle->vertex[2], trianglenormal);
-			VectorNormalize(trianglenormal);
-			PolygonF_QuadForPlane(clipbuf[0][0], trianglenormal[0], trianglenormal[1], trianglenormal[2], DotProduct(trianglenormal, triangle->vertex[0]), model->radius * 2);
-			VectorCopy(trianglenormal, samplenormal); // FIXME!
 			for (y = 0;y < triangle->lmsize[1];y++)
 			{
-				row_numpoints = PolygonF_Clip(4            , clipbuf[0][0],  row_plane[0],  row_plane[1],  row_plane[2],   triangle->lmbase[1] +  y    / triangle->lmscale[1] , LM_DIST_EPSILON, 8, clipbuf[1][0]);
-				if (!row_numpoints)
-					continue;
-				row_numpoints = PolygonF_Clip(row_numpoints, clipbuf[1][0], -row_plane[0], -row_plane[1], -row_plane[2], -(triangle->lmbase[1] + (y+1) / triangle->lmscale[1]), LM_DIST_EPSILON, 8, clipbuf[2][0]);
-				if (!row_numpoints)
-					continue;
-				pixeloffset = triangle->lightmapindex * lm_texturesize * lm_texturesize * 4 + (y+triangle->lmoffset[1]) * lm_texturesize * 4 + triangle->lmoffset[0] * 4;
+				pixeloffset = ((triangle->lightmapindex * lm_texturesize + y + triangle->lmoffset[1]) * lm_texturesize + triangle->lmoffset[0]) * 4;
 				for (x = 0;x < triangle->lmsize[0];x++, pixeloffset += 4)
 				{
-					column_numpoints = PolygonF_Clip(row_numpoints   , clipbuf[2][0],  column_plane[0],  column_plane[1],  column_plane[2],   triangle->lmbase[0] +  x    / triangle->lmscale[0] , LM_DIST_EPSILON, 8, clipbuf[3][0]);
-					if (!column_numpoints)
-						continue;
-					column_numpoints = PolygonF_Clip(column_numpoints, clipbuf[3][0], -column_plane[0], -column_plane[1], -column_plane[2], -(triangle->lmbase[0] + (x+1) / triangle->lmscale[0]), LM_DIST_EPSILON, 8, clipbuf[4][0]);
-					if (!column_numpoints)
-						continue;
-					// we now have a polygon fragment in clipbuf[4], we can
-					// sample its center or subdivide it further for
-					// antialiasing
-					VectorClear(samplecenter);
-					for (j = 0;j < column_numpoints;j++)
-						VectorAdd(samplecenter, clipbuf[4][j], samplecenter);
-					f = 1.0f / column_numpoints;
-					VectorScale(samplecenter, f, samplecenter);
-					VectorMA(samplecenter, 0.125f, trianglenormal, samplecenter);
-					Mod_GenerateLightmaps_Sample(samplecenter, samplenormal, NULL, lightmappixels + pixeloffset, deluxemappixels + pixeloffset);
+					samplecenter[axis1] = (x+0.5f)*lmiscale[0] + triangle->lmbase[0];
+					samplecenter[axis2] = (y+0.5f)*lmiscale[1] + triangle->lmbase[1];
+					samplecenter[axis] = samplecenter[axis1]*slopex + samplecenter[axis2]*slopey + slopebase;
+					VectorMA(samplecenter, 0.125f, samplenormal, samplecenter);
+					Mod_GenerateLightmaps_LightmapSample(samplecenter, samplenormal, lightmappixels + pixeloffset, deluxemappixels + pixeloffset);
 				}
 			}
 		}
@@ -3462,8 +3740,8 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 
 	for (lightmapindex = 0;lightmapindex < model->brushq3.num_mergedlightmaps;lightmapindex++)
 	{
-		model->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("lightmap%i", lightmapnumber), lm_texturesize, lm_texturesize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
-		model->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("deluxemap%i", lightmapnumber), lm_texturesize, lm_texturesize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+		model->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("lightmap%i", lightmapindex), lm_texturesize, lm_texturesize, lightmappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+		model->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("deluxemap%i", lightmapindex), lm_texturesize, lm_texturesize, deluxemappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
 	}
 
 	if (lightmappixels)
@@ -3477,51 +3755,59 @@ static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
 		e = model->surfmesh.data_element3i + surface->num_firsttriangle*3;
 		if (!surface->num_triangles)
 			continue;
-		if (model->brushq3.num_mergedlightmaps)
-		{
-			lightmapindex = mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle].lightmapindex;
-			surface->lightmaptexture = model->brushq3.data_lightmaps[lightmapindex];
-			surface->deluxemaptexture = model->brushq3.data_deluxemaps[lightmapindex];
-		}
-		else
+		lightmapindex = mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle].lightmapindex;
+		surface->lightmaptexture = model->brushq3.data_lightmaps[lightmapindex];
+		surface->deluxemaptexture = model->brushq3.data_deluxemaps[lightmapindex];
+	}
+}
+
+static void Mod_GenerateLightmaps_UpdateVertexColors(dp_model_t *model)
+{
+	int i;
+	for (i = 0;i < model->surfmesh.num_vertices;i++)
+		Mod_GenerateLightmaps_VertexSample(model->surfmesh.data_vertex3f + 3*i, model->surfmesh.data_normal3f + 3*i, model->surfmesh.data_lightmapcolor4f + 4*i);
+}
+
+static void Mod_GenerateLightmaps_UpdateLightGrid(dp_model_t *model)
+{
+	int x;
+	int y;
+	int z;
+	int index = 0;
+	float pos[3];
+	for (z = 0;z < model->brushq3.num_lightgrid_isize[2];z++)
+	{
+		pos[2] = (model->brushq3.num_lightgrid_imins[2] + z + 0.5f) * model->brushq3.num_lightgrid_cellsize[2];
+		for (y = 0;y < model->brushq3.num_lightgrid_isize[1];y++)
 		{
-			surface->lightmaptexture = NULL;
-			surface->deluxemaptexture = NULL;
+			pos[1] = (model->brushq3.num_lightgrid_imins[1] + y + 0.5f) * model->brushq3.num_lightgrid_cellsize[1];
+			for (x = 0;x < model->brushq3.num_lightgrid_isize[0];x++, index++)
+			{
+				pos[0] = (model->brushq3.num_lightgrid_imins[0] + x + 0.5f) * model->brushq3.num_lightgrid_cellsize[0];
+				Mod_GenerateLightmaps_GridSample(pos, model->brushq3.data_lightgrid + index);
+			}
 		}
 	}
 }
 
+extern cvar_t mod_q3bsp_nolightmaps;
 static void Mod_GenerateLightmaps(dp_model_t *model)
 {
 	//lightmaptriangle_t *lightmaptriangles = Mem_Alloc(model->mempool, model->surfmesh.num_triangles * sizeof(lightmaptriangle_t));
 	dp_model_t *oldloadmodel = loadmodel;
 	loadmodel = model;
 
+	Mod_GenerateLightmaps_InitSampleOffsets(model);
 	Mod_GenerateLightmaps_DestroyLightmaps(model);
 	Mod_GenerateLightmaps_UnweldTriangles(model);
 	Mod_GenerateLightmaps_CreateTriangleInformation(model);
-	Mod_GenerateLightmaps_ClassifyTriangles(model);
-	Mod_GenerateLightmaps_AllocateLightmaps(model);
-#if 0
-	// stage 1:
-	// first step is deleting the lightmaps
-	for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
-	{
-		surface = model->data_surfaces + surfaceindex;
-		surface->lightmap = NULL;
-		surface->deluxemap = NULL;
-		// add a sample for each vertex of surface
-		for (i = 0, vertexindex = surface->num_firstvertex;i < surface->num_vertices;i++, vertexindex++)
-			Mod_GenerateLightmaps_AddSample(model->surfmesh.data_vertex3f + 3*vertexindex, model->surfmesh.data_normal3f + 3*vertexindex, model->surfmesh.data_lightmapcolor4f + 4*vertexindex, NULL, NULL);
-		// generate lightmaptriangle_t for each triangle of surface
-		for (i = 0, triangleindex = surface->num_firstvertex;i < surface->num_triangles;i++, triangleindex++)
-		{
-	}
-#endif
-
-	if (mod_generatelightmaps_lightmaptriangles)
-		Mem_Free(mod_generatelightmaps_lightmaptriangles);
-	mod_generatelightmaps_lightmaptriangles = NULL;
+	Mod_GenerateLightmaps_CreateLights(model);
+	if(!mod_q3bsp_nolightmaps.integer)
+		Mod_GenerateLightmaps_CreateLightmaps(model);
+	Mod_GenerateLightmaps_UpdateVertexColors(model);
+	Mod_GenerateLightmaps_UpdateLightGrid(model);
+	Mod_GenerateLightmaps_DestroyLights(model);
+	Mod_GenerateLightmaps_DestroyTriangleInformation(model);
 
 	loadmodel = oldloadmodel;
 }