X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=model_shared.c;h=2be02ff9b017610520bbc8189bb624096b7284e3;hb=e258e3fe3240de023926bc7642159fc80e6fee62;hp=fc0c371785eecd57aa7c5f015e7448461635ea57;hpb=d090340b054029faddb432e2c66085e6e91abcf7;p=xonotic%2Fdarkplaces.git

diff --git a/model_shared.c b/model_shared.c
index fc0c3717..2be02ff9 100644
--- a/model_shared.c
+++ b/model_shared.c
@@ -100,7 +100,7 @@ static void mod_shutdown(void)
 static void mod_newmap(void)
 {
 	msurface_t *surface;
-	int i, j, k, surfacenum, ssize, tsize;
+	int i, j, k, l, surfacenum, ssize, tsize;
 	int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
 	dp_model_t *mod;
 
@@ -110,10 +110,11 @@ static void mod_newmap(void)
 		{
 			for (j = 0;j < mod->num_textures && mod->data_textures;j++)
 			{
-				for (k = 0;k < mod->data_textures[j].numskinframes;k++)
-					R_SkinFrame_MarkUsed(mod->data_textures[j].skinframes[k]);
-				for (k = 0;k < mod->data_textures[j].backgroundnumskinframes;k++)
-					R_SkinFrame_MarkUsed(mod->data_textures[j].backgroundskinframes[k]);
+				// note that materialshaderpass and backgroundshaderpass point to shaderpasses[] and so do the pre/post shader ranges, so this catches all of them...
+				for (l = 0; l < Q3SHADER_MAXLAYERS; l++)
+					if (mod->data_textures[j].shaderpasses[l])
+						for (k = 0; k < mod->data_textures[j].shaderpasses[l]->numframes; k++)
+							R_SkinFrame_MarkUsed(mod->data_textures[j].shaderpasses[l]->skinframes[k]);
 			}
 			if (mod->brush.solidskyskinframe)
 				R_SkinFrame_MarkUsed(mod->brush.solidskyskinframe);
@@ -348,7 +349,9 @@ static void Mod_FindPotentialDeforms(dp_model_t *mod)
 	for (i = 0;i < mod->num_textures;i++)
 	{
 		texture = mod->data_textures + i;
-		if (texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
+		if (texture->materialshaderpass && texture->materialshaderpass->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
+			mod->wantnormals = true;
+		if (texture->materialshaderpass && texture->materialshaderpass->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
 			mod->wantnormals = true;
 		for (j = 0;j < Q3MAXDEFORMS;j++)
 		{
@@ -921,7 +924,7 @@ static void Mod_BuildBumpVectors(const float *v0, const float *v1, const float *
 void Mod_BuildTextureVectorsFromNormals(int firstvertex, int numvertices, int numtriangles, const float *vertex3f, const float *texcoord2f, const float *normal3f, const int *elements, float *svector3f, float *tvector3f, qboolean areaweighting)
 {
 	int i, tnum;
-	float sdir[3], tdir[3], normal[3], *sv, *tv;
+	float sdir[3], tdir[3], normal[3], *svec, *tvec;
 	const float *v0, *v1, *v2, *tc0, *tc1, *tc2, *n;
 	float f, tangentcross[3], v10[3], v20[3], tc10[2], tc20[2];
 	const int *e;
@@ -987,14 +990,14 @@ void Mod_BuildTextureVectorsFromNormals(int firstvertex, int numvertices, int nu
 	// make the tangents completely perpendicular to the surface normal, and
 	// then normalize them
 	// 16 assignments, 2 divide, 2 sqrt, 2 negates, 14 adds, 24 multiplies
-	for (i = 0, sv = svector3f + 3 * firstvertex, tv = tvector3f + 3 * firstvertex, n = normal3f + 3 * firstvertex;i < numvertices;i++, sv += 3, tv += 3, n += 3)
+	for (i = 0, svec = svector3f + 3 * firstvertex, tvec = tvector3f + 3 * firstvertex, n = normal3f + 3 * firstvertex;i < numvertices;i++, svec += 3, tvec += 3, n += 3)
 	{
-		f = -DotProduct(sv, n);
-		VectorMA(sv, f, n, sv);
-		VectorNormalize(sv);
-		f = -DotProduct(tv, n);
-		VectorMA(tv, f, n, tv);
-		VectorNormalize(tv);
+		f = -DotProduct(svec, n);
+		VectorMA(svec, f, n, svec);
+		VectorNormalize(svec);
+		f = -DotProduct(tvec, n);
+		VectorMA(tvec, f, n, tvec);
+		VectorNormalize(tvec);
 	}
 }
 
@@ -1578,7 +1581,7 @@ static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
 	unsigned short hash = CRC_Block_CaseInsensitive ((const unsigned char *)shader->name, strlen (shader->name));
 	q3shader_hash_entry_t* entry = q3shader_data->hash + (hash % Q3SHADER_HASH_SIZE);
 	q3shader_hash_entry_t* lastEntry = NULL;
-	while (entry != NULL)
+	do
 	{
 		if (strcasecmp (entry->shader.name, shader->name) == 0)
 		{
@@ -1611,6 +1614,7 @@ static void Q3Shader_AddToHash (q3shaderinfo_t* shader)
 		lastEntry = entry;
 		entry = entry->chain;
 	}
+	while (entry != NULL);
 	if (entry == NULL)
 	{
 		if (lastEntry->shader.name[0] != 0)
@@ -1726,8 +1730,6 @@ void Mod_LoadQ3Shaders(void)
 			shader.lighting = false;
 			shader.vertexalpha = false;
 			shader.textureblendalpha = false;
-			shader.primarylayer = 0;
-			shader.backgroundlayer = 0;
 			shader.skyboxname[0] = 0;
 			shader.deforms[0].deform = Q3DEFORM_NONE;
 			shader.dpnortlight = false;
@@ -2379,30 +2381,6 @@ void Mod_LoadQ3Shaders(void)
 			// hide this shader if a cvar said it should be killed
 			if (shader.dpshaderkill)
 				shader.numlayers = 0;
-			// pick the primary layer to render with
-			if (shader.numlayers)
-			{
-				shader.backgroundlayer = -1;
-				shader.primarylayer = 0;
-				// if lightmap comes first this is definitely an ordinary texture
-				// if the first two layers have the correct blendfuncs and use vertex alpha, it is a blended terrain shader
-				if ((shader.layers[shader.primarylayer].texturename != NULL)
-				  && !strcasecmp(shader.layers[shader.primarylayer].texturename[0], "$lightmap"))
-				{
-					shader.backgroundlayer = -1;
-					shader.primarylayer = 1;
-				}
-				else if (shader.numlayers >= 2
-				&&   shader.layers[1].alphagen.alphagen == Q3ALPHAGEN_VERTEX
-				&&  (shader.layers[0].blendfunc[0] == GL_ONE       && shader.layers[0].blendfunc[1] == GL_ZERO                && !shader.layers[0].alphatest)
-				&& ((shader.layers[1].blendfunc[0] == GL_SRC_ALPHA && shader.layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA)
-				||  (shader.layers[1].blendfunc[0] == GL_ONE       && shader.layers[1].blendfunc[1] == GL_ZERO                &&  shader.layers[1].alphatest)))
-				{
-					// terrain blending or other effects
-					shader.backgroundlayer = 0;
-					shader.primarylayer = 1;
-				}
-			}
 			// fix up multiple reflection types
 			if(shader.textureflags & Q3TEXTUREFLAG_WATERSHADER)
 				shader.textureflags &= ~(Q3TEXTUREFLAG_REFRACTION | Q3TEXTUREFLAG_REFLECTION | Q3TEXTUREFLAG_CAMERA);
@@ -2434,15 +2412,59 @@ q3shaderinfo_t *Mod_LookupQ3Shader(const char *name)
 	return NULL;
 }
 
-qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qboolean warnmissing, qboolean fallback, int defaulttexflags)
+texture_shaderpass_t *Mod_CreateShaderPass(skinframe_t *skinframe)
+{
+	texture_shaderpass_t *shaderpass = (texture_shaderpass_t *)Mem_Alloc(loadmodel->mempool, sizeof(*shaderpass));
+	shaderpass->framerate = 0.0f;
+	shaderpass->numframes = 1;
+	shaderpass->blendfunc[0] = GL_ONE;
+	shaderpass->blendfunc[1] = GL_ZERO;
+	shaderpass->rgbgen.rgbgen = Q3RGBGEN_IDENTITY;
+	shaderpass->alphagen.alphagen = Q3ALPHAGEN_IDENTITY;
+	shaderpass->alphatest = false;
+	shaderpass->tcgen.tcgen = Q3TCGEN_TEXTURE;
+	shaderpass->skinframes[0] = skinframe;
+	return shaderpass;
+}
+
+texture_shaderpass_t *Mod_CreateShaderPassFromQ3ShaderLayer(q3shaderinfo_layer_t *layer, int layerindex, int texflags, const char *texturename)
 {
 	int j;
+	texture_shaderpass_t *shaderpass = (texture_shaderpass_t *)Mem_Alloc(loadmodel->mempool, sizeof(*shaderpass));
+	shaderpass->alphatest = layer->alphatest != 0;
+	shaderpass->framerate = layer->framerate;
+	shaderpass->numframes = layer->numframes;
+	shaderpass->blendfunc[0] = layer->blendfunc[0];
+	shaderpass->blendfunc[1] = layer->blendfunc[1];
+	shaderpass->rgbgen = layer->rgbgen;
+	shaderpass->alphagen = layer->alphagen;
+	shaderpass->tcgen = layer->tcgen;
+	for (j = 0; j < Q3MAXTCMODS && layer->tcmods[j].tcmod != Q3TCMOD_NONE; j++)
+		shaderpass->tcmods[j] = layer->tcmods[j];
+	for (j = 0; j < layer->numframes; j++)
+	{
+		if (cls.state == ca_dedicated)
+		{
+			shaderpass->skinframes[j] = NULL;
+		}
+		else if (!(shaderpass->skinframes[j] = R_SkinFrame_LoadExternal(layer->texturename[j], texflags, false)))
+		{
+			Con_Printf("^1%s:^7 could not load texture ^3\"%s\"^7 (frame %i) for layer %i of shader ^2\"%s\"\n", loadmodel->name, layer->texturename[j], j, layerindex, texturename);
+			shaderpass->skinframes[j] = R_SkinFrame_LoadMissing();
+		}
+	}
+	return shaderpass;
+}
+
+qboolean Mod_LoadTextureFromQ3Shader(texture_t *texture, const char *name, qboolean warnmissing, qboolean fallback, int defaulttexflags)
+{
 	int texflagsmask, texflagsor;
 	qboolean success = true;
 	q3shaderinfo_t *shader;
 	if (!name)
 		name = "";
 	strlcpy(texture->name, name, sizeof(texture->name));
+	texture->basealpha = 1.0f;
 	shader = name[0] ? Mod_LookupQ3Shader(name) : NULL;
 
 	texflagsmask = ~0;
@@ -2547,51 +2569,99 @@ nothing                GL_ZERO GL_ONE
 		}
 		if (!shader->lighting)
 			texture->basematerialflags |= MATERIALFLAG_FULLBRIGHT;
-		if (shader->primarylayer >= 0)
+
+		// here be dragons: convert quake3 shaders to material
+		if (shader->numlayers > 0)
 		{
-			q3shaderinfo_layer_t* primarylayer = shader->layers + shader->primarylayer;
-			// copy over many primarylayer parameters
-			texture->rgbgen = primarylayer->rgbgen;
-			texture->alphagen = primarylayer->alphagen;
-			texture->tcgen = primarylayer->tcgen;
-			memcpy(texture->tcmods, primarylayer->tcmods, sizeof(texture->tcmods));
-			// load the textures
-			texture->numskinframes = primarylayer->numframes;
-			texture->skinframerate = primarylayer->framerate;
-			for (j = 0;j < primarylayer->numframes;j++)
+			int i;
+			int terrainbackgroundlayer = -1;
+			int lightmaplayer = -1;
+			int alphagenspecularlayer = -1;
+			int rgbgenvertexlayer = -1;
+			int rgbgendiffuselayer = -1;
+			int materiallayer = -1;
+			int endofprelayers = 0;
+			int firstpostlayer = 0;
+			int shaderpassindex = 0;
+			for (i = 0; i < shader->numlayers; i++)
 			{
-				if(cls.state == ca_dedicated)
-				{
-					texture->skinframes[j] = NULL;
-				}
-				else if (!(texture->skinframes[j] = R_SkinFrame_LoadExternal(primarylayer->texturename[j], (primarylayer->texflags & texflagsmask) | texflagsor, false)))
-				{
-					Con_Printf("^1%s:^7 could not load texture ^3\"%s\"^7 (frame %i) for shader ^2\"%s\"\n", loadmodel->name, primarylayer->texturename[j], j, texture->name);
-					texture->skinframes[j] = R_SkinFrame_LoadMissing();
-				}
+				if (shader->layers[i].texturename != NULL && !strcasecmp(shader->layers[i].texturename[0], "$lightmap"))
+					lightmaplayer = i;
+				if (shader->layers[i].rgbgen.rgbgen == Q3RGBGEN_VERTEX)
+					rgbgenvertexlayer = i;
+				if (shader->layers[i].rgbgen.rgbgen == Q3RGBGEN_LIGHTINGDIFFUSE)
+					rgbgendiffuselayer = i;
+				if (shader->layers[i].alphagen.alphagen == Q3ALPHAGEN_LIGHTINGSPECULAR)
+					alphagenspecularlayer = i;
 			}
-		}
-		if (shader->backgroundlayer >= 0)
-		{
-			q3shaderinfo_layer_t* backgroundlayer = shader->layers + shader->backgroundlayer;
-			// copy over one secondarylayer parameter
-			memcpy(texture->backgroundtcmods, backgroundlayer->tcmods, sizeof(texture->backgroundtcmods));
-			// load the textures
-			texture->backgroundnumskinframes = backgroundlayer->numframes;
-			texture->backgroundskinframerate = backgroundlayer->framerate;
-			for (j = 0;j < backgroundlayer->numframes;j++)
+			if (shader->numlayers >= 2
+			 && shader->layers[1].alphagen.alphagen == Q3ALPHAGEN_VERTEX
+			 && (shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ZERO && !shader->layers[0].alphatest)
+			 && ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA)
+				 || (shader->layers[1].blendfunc[0] == GL_ONE && shader->layers[1].blendfunc[1] == GL_ZERO && shader->layers[1].alphatest)))
 			{
-				if(cls.state == ca_dedicated)
-				{
-					texture->skinframes[j] = NULL;
-				}
-				else if (!(texture->backgroundskinframes[j] = R_SkinFrame_LoadExternal(backgroundlayer->texturename[j], (backgroundlayer->texflags & texflagsmask) | texflagsor, false)))
-				{
-					Con_Printf("^1%s:^7 could not load texture ^3\"%s\"^7 (background frame %i) for shader ^2\"%s\"\n", loadmodel->name, backgroundlayer->texturename[j], j, texture->name);
-					texture->backgroundskinframes[j] = R_SkinFrame_LoadMissing();
-				}
+				// terrain blend or certain other effects involving alphatest over a regular layer
+				terrainbackgroundlayer = 0;
+				materiallayer = 1;
+				// terrain may be vertex lit (in which case both layers are rgbGen vertex) or lightmapped (in which ase the third layer is lightmap)
+				firstpostlayer = lightmaplayer >= 0 ? lightmaplayer + 1 : materiallayer + 1;
 			}
+			else if (lightmaplayer == 0)
+			{
+				// ordinary texture but with $lightmap before diffuse
+				materiallayer = 1;
+				firstpostlayer = lightmaplayer + 2;
+			}
+			else if (lightmaplayer >= 1)
+			{
+				// ordinary texture - we don't properly apply lighting to the prelayers, but oh well...
+				endofprelayers = lightmaplayer - 1;
+				materiallayer = lightmaplayer - 1;
+				firstpostlayer = lightmaplayer + 1;
+			}
+			else if (rgbgenvertexlayer >= 0)
+			{
+				// map models with baked lighting
+				materiallayer = rgbgenvertexlayer;
+				endofprelayers = rgbgenvertexlayer;
+				firstpostlayer = rgbgenvertexlayer + 1;
+			}
+			else if (rgbgendiffuselayer >= 0)
+			{
+				// entity models with dynamic lighting
+				materiallayer = rgbgendiffuselayer;
+				endofprelayers = rgbgendiffuselayer;
+				firstpostlayer = rgbgendiffuselayer + 1;
+				// player models often have specular as a pass after diffuse - we don't currently make use of that specular texture (would need to meld it into the skinframe)...
+				if (alphagenspecularlayer >= 0)
+					firstpostlayer = alphagenspecularlayer + 1;
+			}
+			else
+			{
+				// special effects shaders - treat first as primary layer and do everything else as post
+				endofprelayers = 0;
+				materiallayer = 0;
+				firstpostlayer = 1;
+			}
+			// convert the main material layer
+			// FIXME: if alphagenspecularlayer is used, we should pass a specular texture name to R_SkinFrame_LoadExternal and have it load that texture instead of the assumed name for _gloss texture
+			if (materiallayer >= 0)
+				texture->materialshaderpass = texture->shaderpasses[shaderpassindex++] = Mod_CreateShaderPassFromQ3ShaderLayer(&shader->layers[materiallayer], materiallayer, (shader->layers[materiallayer].texflags & texflagsmask) | texflagsor, texture->name);
+			// convert the terrain background blend layer (if any)
+			if (terrainbackgroundlayer >= 0)
+				texture->backgroundshaderpass = texture->shaderpasses[shaderpassindex++] = Mod_CreateShaderPassFromQ3ShaderLayer(&shader->layers[terrainbackgroundlayer], terrainbackgroundlayer, (shader->layers[terrainbackgroundlayer].texflags & texflagsmask) | texflagsor, texture->name);
+			// convert the prepass layers (if any)
+			texture->startpreshaderpass = shaderpassindex;
+			for (i = 0; i < endofprelayers; i++)
+				texture->shaderpasses[shaderpassindex++] = Mod_CreateShaderPassFromQ3ShaderLayer(&shader->layers[i], i, (shader->layers[i].texflags & texflagsmask) | texflagsor, texture->name);
+			texture->endpreshaderpass = shaderpassindex;
+			texture->startpostshaderpass = shaderpassindex;
+			// convert the postpass layers (if any)
+			for (i = firstpostlayer; i < shader->numlayers; i++)
+				texture->shaderpasses[shaderpassindex++] = Mod_CreateShaderPassFromQ3ShaderLayer(&shader->layers[i], i, (shader->layers[i].texflags & texflagsmask) | texflagsor, texture->name);
+			texture->startpostshaderpass = shaderpassindex;
 		}
+
 		if (shader->dpshadow)
 			texture->basematerialflags &= ~MATERIALFLAG_NOSHADOW;
 		if (shader->dpnoshadow)
@@ -2732,20 +2802,22 @@ nothing                GL_ZERO GL_ONE
 			texture->basematerialflags |= MATERIALFLAG_WALL;
 			texture->supercontents = SUPERCONTENTS_SOLID | SUPERCONTENTS_OPAQUE;
 		}
-		texture->numskinframes = 1;
 		if(cls.state == ca_dedicated)
 		{
-			texture->skinframes[0] = NULL;
+			texture->materialshaderpass = NULL;
 			success = false;
 		}
 		else
 		{
 			if (fallback)
 			{
-				if ((texture->skinframes[0] = R_SkinFrame_LoadExternal(texture->name, defaulttexflags, false)))
+				texture->materialshaderpass = texture->shaderpasses[0] = Mod_CreateShaderPass(R_SkinFrame_LoadExternal(texture->name, defaulttexflags, false));
+				if (texture->materialshaderpass->skinframes[0])
 				{
-					if(texture->skinframes[0]->hasalpha)
+					if (texture->materialshaderpass->skinframes[0]->hasalpha)
 						texture->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
+					if (texture->q2contents)
+						texture->supercontents = Mod_Q2BSP_SuperContentsFromNativeContents(loadmodel, texture->q2contents);
 				}
 				else
 					success = false;
@@ -2758,12 +2830,12 @@ nothing                GL_ZERO GL_ONE
 	}
 	// init the animation variables
 	texture->currentframe = texture;
-	if (texture->numskinframes < 1)
-		texture->numskinframes = 1;
-	if (!texture->skinframes[0])
-		texture->skinframes[0] = R_SkinFrame_LoadMissing();
-	texture->currentskinframe = texture->skinframes[0];
-	texture->backgroundcurrentskinframe = texture->backgroundskinframes[0];
+	if (!texture->materialshaderpass)
+		texture->materialshaderpass = texture->shaderpasses[0] = Mod_CreateShaderPass(R_SkinFrame_LoadMissing());
+	if (!texture->materialshaderpass->skinframes[0])
+		texture->materialshaderpass->skinframes[0] = R_SkinFrame_LoadMissing();
+	texture->currentskinframe = texture->materialshaderpass ? texture->materialshaderpass->skinframes[0] : NULL;
+	texture->backgroundcurrentskinframe = texture->backgroundshaderpass ? texture->backgroundshaderpass->skinframes[0] : NULL;
 	return success;
 }
 
@@ -2963,7 +3035,7 @@ void Mod_MakeSortedSurfaces(dp_model_t *mod)
 	for (j = 0;j < mod->nummodelsurfaces;j++)
 	{
 		const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface;
-		int t = (int)(surface->texture - mod->data_textures);
+		t = (int)(surface->texture - mod->data_textures);
 		numsurfacesfortexture[t]++;
 	}
 	j = 0;
@@ -2975,7 +3047,7 @@ void Mod_MakeSortedSurfaces(dp_model_t *mod)
 	for (j = 0;j < mod->nummodelsurfaces;j++)
 	{
 		const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface;
-		int t = (int)(surface->texture - mod->data_textures);
+		t = (int)(surface->texture - mod->data_textures);
 		mod->sortedmodelsurfaces[firstsurfacefortexture[t]++] = j + mod->firstmodelsurface;
 	}
 	Mem_Free(firstsurfacefortexture);
@@ -3488,14 +3560,14 @@ static void Mod_Decompile_f(void)
 	}
 }
 
-void Mod_AllocLightmap_Init(mod_alloclightmap_state_t *state, int width, int height)
+void Mod_AllocLightmap_Init(mod_alloclightmap_state_t *state, mempool_t *mempool, int width, int height)
 {
 	int y;
 	memset(state, 0, sizeof(*state));
 	state->width = width;
 	state->height = height;
 	state->currentY = 0;
-	state->rows = (mod_alloclightmap_row_t *)Mem_Alloc(loadmodel->mempool, state->height * sizeof(*state->rows));
+	state->rows = (mod_alloclightmap_row_t *)Mem_Alloc(mempool, state->height * sizeof(*state->rows));
 	for (y = 0;y < state->height;y++)
 	{
 		state->rows[y].currentX = 0;
@@ -3660,7 +3732,7 @@ static void Mod_GenerateLightmaps_LightPoint(dp_model_t *model, const vec3_t pos
 			continue;
 		if (model && model->TraceLine)
 		{
-			model->TraceLine(model, NULL, NULL, &trace, pos, lightorigin, SUPERCONTENTS_VISBLOCKERMASK);
+			model->TraceLine(model, NULL, NULL, &trace, pos, lightorigin, SUPERCONTENTS_VISBLOCKERMASK, SUPERCONTENTS_SKY);
 			if (trace.fraction < 1)
 				continue;
 		}
@@ -3862,7 +3934,7 @@ static void Mod_GenerateLightmaps_SamplePoint(const float *pos, const float *nor
 				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);
+					cl.worldmodel->TraceLine(cl.worldmodel, NULL, NULL, &trace, pos, offsetpos, SUPERCONTENTS_VISBLOCKERMASK, SUPERCONTENTS_SKY);
 					if (trace.fraction < 1)
 						VectorLerp(pos, trace.fraction, offsetpos, offsetpos);
 				}
@@ -4198,7 +4270,7 @@ static void Mod_GenerateLightmaps_CreateLightmaps(dp_model_t *model)
 	lm_borderpixels = mod_generatelightmaps_borderpixels.integer;
 	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);
+	Mod_AllocLightmap_Init(&lmstate, loadmodel->mempool, lm_texturesize, lm_texturesize);
 	lightmapnumber = 0;
 	for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
 	{
@@ -4246,7 +4318,7 @@ static void Mod_GenerateLightmaps_CreateLightmaps(dp_model_t *model)
 				surfaceindex = -1;
 				lightmapnumber = 0;
 				Mod_AllocLightmap_Free(&lmstate);
-				Mod_AllocLightmap_Init(&lmstate, lm_texturesize, lm_texturesize);
+				Mod_AllocLightmap_Init(&lmstate, loadmodel->mempool, lm_texturesize, lm_texturesize);
 				break;
 			}
 			// if we have maxed out the lightmap size, and this triangle does