X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_models.c;h=223be1b81b87af20c877d54b988831638ee23e9e;hp=bb63bf3d6e212997155977b21b5b6b712e8a6116;hb=699c77ca2c9fd357fbe479f00e778486becfd840;hpb=b12d762f20e92c9dc0e0acb792de674fc90f6160

diff --git a/gl_models.c b/gl_models.c
index bb63bf3d..223be1b8 100644
--- a/gl_models.c
+++ b/gl_models.c
@@ -13,6 +13,7 @@ int aliasvertmax = 0;
 void *aliasvertarrays = NULL;
 float *aliasvertcolor4fbuf = NULL;
 float *aliasvertcolor4f = NULL; // this may point at aliasvertcolorbuf or at vertex arrays in the mesh backend
+float *aliasvert_vertex3f = NULL;
 float *aliasvert_svector3f = NULL;
 float *aliasvert_tvector3f = NULL;
 float *aliasvert_normal3f = NULL;
@@ -31,10 +32,11 @@ void gl_models_allocarrays(int newmax)
 	aliasvertmax = newmax;
 	if (aliasvertarrays != NULL)
 		Mem_Free(aliasvertarrays);
-	aliasvertarrays = Mem_Alloc(gl_models_mempool, aliasvertmax * (sizeof(float[4+4+3+3+3]) + sizeof(int[3])));
+	aliasvertarrays = Mem_Alloc(gl_models_mempool, aliasvertmax * (sizeof(float[4+4+3+3+3+3]) + sizeof(int[3])));
 	data = aliasvertarrays;
 	aliasvertcolor4f = aliasvertcolor4fbuf = (void *)data;data += aliasvertmax * sizeof(float[4]);
 	aliasvertcolor2_4f = (void *)data;data += aliasvertmax * sizeof(float[4]); // used temporarily for tinted coloring
+	aliasvert_vertex3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
 	aliasvert_svector3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
 	aliasvert_tvector3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
 	aliasvert_normal3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
@@ -49,6 +51,7 @@ void gl_models_freearrays(void)
 	aliasvertarrays = NULL;
 	aliasvertcolor4f = aliasvertcolor4fbuf = NULL;
 	aliasvertcolor2_4f = NULL;
+	aliasvert_vertex3f = NULL;
 	aliasvert_svector3f = NULL;
 	aliasvert_tvector3f = NULL;
 	aliasvert_normal3f = NULL;
@@ -78,160 +81,92 @@ void GL_Models_Init(void)
 	R_RegisterModule("GL_Models", gl_models_start, gl_models_shutdown, gl_models_newmap);
 }
 
-void R_Model_Alias_GetMesh_Vertex3f(const entity_render_t *ent, aliasmesh_t *mesh, float *vertex3f, float *normal3f, float *svector3f, float *tvector3f)
+#define MODELARRAY_VERTEX 0
+#define MODELARRAY_SVECTOR 1
+#define MODELARRAY_TVECTOR 2
+#define MODELARRAY_NORMAL 3
+
+void R_Model_Alias_GetMesh_Array3f(const entity_render_t *ent, const aliasmesh_t *mesh, int whicharray, float *out3f)
 {
 	int i, vertcount;
 	float lerp1, lerp2, lerp3, lerp4;
-	const aliasvertex_t *verts1, *verts2, *verts3, *verts4;
+	const float *vertsbase, *verts1, *verts2, *verts3, *verts4;
 
-	if (vertex3f == NULL)
-	 	Host_Error("R_Model_Alias_GetMesh_Vertex3f: vertices == NULL.\n");
-	if (svector3f != NULL && (tvector3f == NULL || normal3f == NULL))
-	 	Host_Error("R_Model_Alias_GetMesh_Vertex3f: svectors requires tvectors and normals.\n");
-	if (tvector3f != NULL && (svector3f == NULL || normal3f == NULL))
-	 	Host_Error("R_Model_Alias_GetMesh_Vertex3f: tvectors requires svectors and normals.\n");
+	switch(whicharray)
+	{
+	case MODELARRAY_VERTEX:vertsbase = mesh->data_aliasvertex3f;break;
+	case MODELARRAY_SVECTOR:vertsbase = mesh->data_aliassvector3f;break;
+	case MODELARRAY_TVECTOR:vertsbase = mesh->data_aliastvector3f;break;
+	case MODELARRAY_NORMAL:vertsbase = mesh->data_aliasnormal3f;break;
+	default:
+		Host_Error("R_Model_Alias_GetBlendedArray: unknown whicharray %i\n", whicharray);
+		return;
+	}
 
 	vertcount = mesh->num_vertices;
-	verts1 = mesh->data_aliasvertex + ent->frameblend[0].frame * vertcount;
+	verts1 = vertsbase + ent->frameblend[0].frame * vertcount * 3;
 	lerp1 = ent->frameblend[0].lerp;
 	if (ent->frameblend[1].lerp)
 	{
-		verts2 = mesh->data_aliasvertex + ent->frameblend[1].frame * vertcount;
+		verts2 = vertsbase + ent->frameblend[1].frame * vertcount * 3;
 		lerp2 = ent->frameblend[1].lerp;
 		if (ent->frameblend[2].lerp)
 		{
-			verts3 = mesh->data_aliasvertex + ent->frameblend[2].frame * vertcount;
+			verts3 = vertsbase + ent->frameblend[2].frame * vertcount * 3;
 			lerp3 = ent->frameblend[2].lerp;
 			if (ent->frameblend[3].lerp)
 			{
-				verts4 = mesh->data_aliasvertex + ent->frameblend[3].frame * vertcount;
+				verts4 = vertsbase + ent->frameblend[3].frame * vertcount * 3;
 				lerp4 = ent->frameblend[3].lerp;
-				// generate vertices
-				if (svector3f != NULL)
-				{
-					for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++, verts2++, verts3++, verts4++)
-					{
-						VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertex3f);
-						VectorMAMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, lerp4, verts4->normal, normal3f);
-						VectorMAMAMAM(lerp1, verts1->svector, lerp2, verts2->svector, lerp3, verts3->svector, lerp4, verts4->svector, svector3f);
-						CrossProduct(svector3f, normal3f, tvector3f);
-					}
-				}
-				else if (normal3f != NULL)
-				{
-					for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++, verts2++, verts3++, verts4++)
-					{
-						VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertex3f);
-						VectorMAMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, lerp4, verts4->normal, normal3f);
-					}
-				}
-				else
-					for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++, verts2++, verts3++, verts4++)
-						VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertex3f);
+				for (i = 0;i < vertcount * 3;i++)
+					VectorMAMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, lerp4, verts4 + i, out3f + i);
 			}
 			else
-			{
-				// generate vertices
-				if (svector3f != NULL)
-				{
-					for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++, verts2++, verts3++)
-					{
-						VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertex3f);
-						VectorMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, normal3f);
-						VectorMAMAM(lerp1, verts1->svector, lerp2, verts2->svector, lerp3, verts3->svector, svector3f);
-						CrossProduct(svector3f, normal3f, tvector3f);
-					}
-				}
-				else if (normal3f != NULL)
-				{
-					for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++, verts2++, verts3++)
-					{
-						VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertex3f);
-						VectorMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, normal3f);
-					}
-				}
-				else
-					for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++, verts2++, verts3++)
-						VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertex3f);
-			}
+				for (i = 0;i < vertcount * 3;i++)
+					VectorMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, out3f + i);
 		}
 		else
-		{
-			// generate vertices
-			if (svector3f != NULL)
-			{
-				for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++, verts2++)
-				{
-					VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertex3f);
-					VectorMAM(lerp1, verts1->normal, lerp2, verts2->normal, normal3f);
-					VectorMAM(lerp1, verts1->svector, lerp2, verts2->svector, svector3f);
-					CrossProduct(svector3f, normal3f, tvector3f);
-				}
-			}
-			else if (normal3f != NULL)
-			{
-				for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++, verts2++)
-				{
-					VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertex3f);
-					VectorMAM(lerp1, verts1->normal, lerp2, verts2->normal, normal3f);
-				}
-			}
-			else
-				for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++, verts2++)
-					VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertex3f);
-		}
+			for (i = 0;i < vertcount * 3;i++)
+				VectorMAM(lerp1, verts1 + i, lerp2, verts2 + i, out3f + i);
 	}
 	else
-	{
-		// generate vertices
-		if (svector3f != NULL)
-		{
-			for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++)
-			{
-				VectorCopy(verts1->origin, vertex3f);
-				VectorCopy(verts1->normal, normal3f);
-				VectorCopy(verts1->svector, svector3f);
-				CrossProduct(svector3f, normal3f, tvector3f);
-			}
-		}
-		else if (normal3f != NULL)
-		{
-			for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++)
-			{
-				VectorCopy(verts1->origin, vertex3f);
-				VectorCopy(verts1->normal, normal3f);
-			}
-		}
-		else
-			for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++)
-				VectorCopy(verts1->origin, vertex3f);
-	}
+		memcpy(out3f, verts1, vertcount * sizeof(float[3]));
 }
 
+aliaslayer_t r_aliasnoskinlayers[2] = {{ALIASLAYER_DIFFUSE, NULL, NULL}, {ALIASLAYER_FOG | ALIASLAYER_FORCEDRAW_IF_FIRSTPASS, NULL, NULL}};
+aliasskin_t r_aliasnoskin = {0, 2, r_aliasnoskinlayers};
 aliasskin_t *R_FetchAliasSkin(const entity_render_t *ent, const aliasmesh_t *mesh)
 {
 	model_t *model = ent->model;
-	int s = ent->skinnum;
-	if ((unsigned int)s >= (unsigned int)model->numskins)
-		s = 0;
-	if (model->skinscenes[s].framecount > 1)
-		s = model->skinscenes[s].firstframe + (int) (cl.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
+	if (model->numskins)
+	{
+		int s = ent->skinnum;
+		if ((unsigned int)s >= (unsigned int)model->numskins)
+			s = 0;
+		if (model->skinscenes[s].framecount > 1)
+			s = model->skinscenes[s].firstframe + (int) (cl.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
+		else
+			s = model->skinscenes[s].firstframe;
+		if (s >= mesh->num_skins)
+			s = 0;
+		return mesh->data_skins + s;
+	}
 	else
-		s = model->skinscenes[s].firstframe;
-	if (s >= mesh->num_skins)
-		s = 0;
-	return mesh->data_skins + s;
+	{
+		r_aliasnoskinlayers[0].texture = r_notexture;
+		return &r_aliasnoskin;
+	}
 }
 
 void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
 {
-	int c, fullbright, layernum;
-	float tint[3], fog, ifog, colorscale;
+	int c, fullbright, layernum, firstpass;
+	float tint[3], fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
 	vec3_t diff;
 	qbyte *bcolor;
 	rmeshstate_t m;
 	const entity_render_t *ent = calldata1;
-	aliasmesh_t *mesh = ent->model->aliasdata_meshes + calldata2;
+	aliasmesh_t *mesh = ent->model->alias.aliasdata_meshes + calldata2;
 	aliaslayer_t *layer;
 	aliasskin_t *skin;
 
@@ -240,7 +175,7 @@ void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
 	fog = 0;
 	if (fogenabled)
 	{
-		VectorSubtract(ent->origin, r_origin, diff);
+		VectorSubtract(ent->origin, r_vieworigin, diff);
 		fog = DotProduct(diff,diff);
 		if (fog < 0.01f)
 			fog = 0.01f;
@@ -255,91 +190,97 @@ void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
 	}
 	ifog = 1 - fog;
 
-	memset(&m, 0, sizeof(m));
+	firstpass = true;
 	skin = R_FetchAliasSkin(ent, mesh);
 	for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
 	{
-		if (((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
-		 || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0)
-		 ||  (layer->flags & ALIASLAYER_DRAW_PER_LIGHT))
-			continue;
-		expandaliasvert(mesh->num_vertices);
-		if (layer->flags & ALIASLAYER_FOG)
+		if (!(layer->flags & ALIASLAYER_FORCEDRAW_IF_FIRSTPASS) || !firstpass)
 		{
-			m.blendfunc1 = GL_SRC_ALPHA;
-			m.blendfunc2 = GL_ONE;
-			colorscale = r_colorscale;
-			m.texrgbscale[0] = 1;
-			m.tex[0] = R_GetTexture(layer->texture);
-			R_Mesh_State(&m);
-			GL_Color(fogcolor[0] * fog * colorscale, fogcolor[1] * fog * colorscale, fogcolor[2] * fog * colorscale, ent->alpha);
-			c_alias_polys += mesh->num_triangles;
-			R_Mesh_GetSpace(mesh->num_vertices);
-			R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, aliasvert_normal3f, NULL, NULL);
-			if (layer->texture != NULL)
-				R_Mesh_CopyTexCoord2f(0, mesh->data_texcoord2f, mesh->num_vertices);
-			R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
-			continue;
+			if (((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
+			 || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0)
+			 || ((layer->flags & ALIASLAYER_FOG) && !fogenabled)
+			 ||  (layer->flags & ALIASLAYER_SPECULAR)
+			 || ((layer->flags & ALIASLAYER_DIFFUSE) && (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value <= 0 && r_ambient.integer <= 0 && r_fullbright.integer == 0 && !(ent->effects & EF_FULLBRIGHT))))
+				continue;
 		}
-		if ((layer->flags & ALIASLAYER_ADD) || ((layer->flags & ALIASLAYER_ALPHA) && (ent->effects & EF_ADDITIVE)))
+		if (!firstpass || (ent->effects & EF_ADDITIVE))
 		{
-			m.blendfunc1 = GL_SRC_ALPHA;
-			m.blendfunc2 = GL_ONE;
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+			GL_DepthMask(false);
 		}
-		else if ((layer->flags & ALIASLAYER_ALPHA) || ent->alpha != 1.0)
+		else if ((skin->flags & ALIASSKIN_TRANSPARENT) || ent->alpha != 1.0)
 		{
-			m.blendfunc1 = GL_SRC_ALPHA;
-			m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			GL_DepthMask(false);
 		}
 		else
 		{
-			m.blendfunc1 = GL_ONE;
-			m.blendfunc2 = GL_ZERO;
-		}
-		colorscale = r_colorscale;
-		m.texrgbscale[0] = 1;
-		if (gl_combine.integer)
-		{
-			colorscale *= 0.25f;
-			m.texrgbscale[0] = 4;
+			GL_BlendFunc(GL_ONE, GL_ZERO);
+			GL_DepthMask(true);
 		}
-		m.tex[0] = R_GetTexture(layer->texture);
-		R_Mesh_State(&m);
-		if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
+		GL_DepthTest(true);
+		firstpass = false;
+		expandaliasvert(mesh->num_vertices);
+		colorscale = 1.0f;
+
+		memset(&m, 0, sizeof(m));
+		if (layer->texture != NULL)
 		{
-			// 128-224 are backwards ranges
-			c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
-			bcolor = (qbyte *) (&palette_complete[c]);
-			fullbright = c >= 224;
-			VectorScale(bcolor, (1.0f / 255.0f), tint);
+			m.tex[0] = R_GetTexture(layer->texture);
+			m.pointer_texcoord[0] = mesh->data_texcoord2f;
+			if (gl_combine.integer && layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
+			{
+				colorscale *= 0.25f;
+				m.texrgbscale[0] = 4;
+			}
 		}
-		else if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
+		m.pointer_vertex = varray_vertex3f;
+
+		c_alias_polys += mesh->num_triangles;
+		R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
+		if (layer->flags & ALIASLAYER_FOG)
 		{
-			// 128-224 are backwards ranges
-			c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
-			bcolor = (qbyte *) (&palette_complete[c]);
-			fullbright = c >= 224;
-			VectorScale(bcolor, (1.0f / 255.0f), tint);
+			colorscale *= fog;
+			GL_Color(fogcolor[0] * colorscale, fogcolor[1] * colorscale, fogcolor[2] * colorscale, ent->alpha);
 		}
 		else
 		{
-			tint[0] = tint[1] = tint[2] = 1;
-			fullbright = false;
+			fullbright = !(layer->flags & ALIASLAYER_DIFFUSE) || r_fullbright.integer || (ent->effects & EF_FULLBRIGHT);
+			if (layer->flags & (ALIASLAYER_COLORMAP_PANTS | ALIASLAYER_COLORMAP_SHIRT))
+			{
+				// 128-224 are backwards ranges
+				if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
+					c = (ent->colormap & 0xF) << 4;
+				else //if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
+					c = (ent->colormap & 0xF0);
+				c += (c >= 128 && c < 224) ? 4 : 12;
+				bcolor = (qbyte *) (&palette_complete[c]);
+				fullbright = fullbright || c >= 224;
+				VectorScale(bcolor, (1.0f / 255.0f), tint);
+			}
+			else
+				tint[0] = tint[1] = tint[2] = 1;
+			if (r_shadow_realtime_world.integer && !fullbright)
+				VectorScale(tint, r_shadow_realtime_world_lightmaps.value, tint);
+			colorscale *= ifog;
+			if (fullbright)
+				GL_Color(tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha);
+			else
+			{
+				if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha, false))
+				{
+					m.pointer_color = varray_color4f;
+					R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, varray_normal3f);
+					R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, varray_vertex3f, varray_normal3f, varray_color4f);
+				}
+				else
+					GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
+			}
 		}
-		VectorScale(tint, ifog * colorscale, tint);
-		if (!(layer->flags & ALIASLAYER_DIFFUSE))
-			fullbright = true;
-		if (ent->effects & EF_FULLBRIGHT)
-			fullbright = true;
-		c_alias_polys += mesh->num_triangles;
-		R_Mesh_GetSpace(mesh->num_vertices);
-		R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, aliasvert_normal3f, NULL, NULL);
-		R_Mesh_CopyTexCoord2f(0, mesh->data_texcoord2f, mesh->num_vertices);
-		if (fullbright)
-			GL_Color(tint[0], tint[1], tint[2], ent->alpha);
-		else
-			R_LightModel(ent, mesh->num_vertices, varray_vertex3f, aliasvert_normal3f, varray_color4f, tint[0], tint[1], tint[2], false);
+		R_Mesh_State(&m);
+		GL_LockArrays(0, mesh->num_vertices);
 		R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
+		GL_LockArrays(0, 0);
 	}
 }
 
@@ -352,7 +293,7 @@ void R_Model_Alias_Draw(entity_render_t *ent)
 
 	c_models++;
 
-	for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++, mesh++)
+	for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
 	{
 		if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchAliasSkin(ent, mesh)->flags & ALIASSKIN_TRANSPARENT)
 			R_MeshQueue_AddTransparent(ent->origin, R_DrawAliasModelCallback, ent, meshnum);
@@ -361,66 +302,6 @@ void R_Model_Alias_Draw(entity_render_t *ent)
 	}
 }
 
-void R_Model_Alias_DrawFakeShadow (entity_render_t *ent)
-{
-	int i, meshnum;
-	aliasmesh_t *mesh;
-	aliasskin_t *skin;
-	rmeshstate_t m;
-	float *v, planenormal[3], planedist, dist, projection[3], floororigin[3], surfnormal[3], lightdirection[3], v2[3];
-
-	if ((ent->effects & EF_ADDITIVE) || ent->alpha < 1)
-		return;
-
-	lightdirection[0] = 0.5;
-	lightdirection[1] = 0.2;
-	lightdirection[2] = -1;
-	VectorNormalizeFast(lightdirection);
-
-	VectorMA(ent->origin, 65536.0f, lightdirection, v2);
-	if (CL_TraceLine(ent->origin, v2, floororigin, surfnormal, 0, false, NULL) == 1)
-		return;
-
-	R_Mesh_Matrix(&ent->matrix);
-
-	memset(&m, 0, sizeof(m));
-	m.blendfunc1 = GL_SRC_ALPHA;
-	m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
-	R_Mesh_State(&m);
-	GL_Color(0, 0, 0, 0.5);
-
-	// put a light direction in the entity's coordinate space
-	Matrix4x4_Transform3x3(&ent->inversematrix, lightdirection, projection);
-	VectorNormalizeFast(projection);
-
-	// put the plane's normal in the entity's coordinate space
-	Matrix4x4_Transform3x3(&ent->inversematrix, surfnormal, planenormal);
-	VectorNormalizeFast(planenormal);
-
-	// put the plane's distance in the entity's coordinate space
-	VectorSubtract(floororigin, ent->origin, floororigin);
-	planedist = DotProduct(floororigin, surfnormal) + 2;
-
-	dist = -1.0f / DotProduct(projection, planenormal);
-	VectorScale(projection, dist, projection);
-	for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++)
-	{
-		skin = R_FetchAliasSkin(ent, mesh);
-		if (skin->flags & ALIASSKIN_TRANSPARENT)
-			continue;
-		R_Mesh_GetSpace(mesh->num_vertices);
-		R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
-		for (i = 0, v = varray_vertex3f;i < mesh->num_vertices;i++, v += 3)
-		{
-			dist = DotProduct(v, planenormal) - planedist;
-			if (dist > 0)
-				VectorMA(v, dist, projection, v);
-		}
-		c_alias_polys += mesh->num_triangles;
-		R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
-	}
-}
-
 void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
 {
 	int meshnum;
@@ -429,26 +310,25 @@ void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightor
 	float projectdistance;
 	if (ent->effects & EF_ADDITIVE || ent->alpha < 1)
 		return;
-	projectdistance = lightradius + ent->model->radius - sqrt(DotProduct(relativelightorigin, relativelightorigin));
+	projectdistance = lightradius + ent->model->radius;// - sqrt(DotProduct(relativelightorigin, relativelightorigin));
 	if (projectdistance > 0.1)
 	{
 		R_Mesh_Matrix(&ent->matrix);
-		for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++, mesh++)
+		for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
 		{
 			skin = R_FetchAliasSkin(ent, mesh);
 			if (skin->flags & ALIASSKIN_TRANSPARENT)
 				continue;
-			R_Mesh_GetSpace(mesh->num_vertices * 2);
-			R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
-			R_Shadow_Volume(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, mesh->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
+			R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
+			R_Shadow_VolumeFromSphere(mesh->num_vertices, mesh->num_triangles, varray_vertex3f, mesh->data_element3i, mesh->data_neighbor3i, relativelightorigin, projectdistance, lightradius);
 		}
 	}
 }
 
-void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz)
+void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
 {
 	int c, meshnum, layernum;
-	float fog, ifog, lightcolor2[3], *vertices;
+	float fog, ifog, lightcolor2[3];
 	vec3_t diff;
 	qbyte *bcolor;
 	aliasmesh_t *mesh;
@@ -463,7 +343,7 @@ void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 	fog = 0;
 	if (fogenabled)
 	{
-		VectorSubtract(ent->origin, r_origin, diff);
+		VectorSubtract(ent->origin, r_vieworigin, diff);
 		fog = DotProduct(diff,diff);
 		if (fog < 0.01f)
 			fog = 0.01f;
@@ -478,17 +358,19 @@ void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 	}
 	ifog = 1 - fog;
 
-	for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++, mesh++)
+	for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
 	{
 		skin = R_FetchAliasSkin(ent, mesh);
 		if (skin->flags & ALIASSKIN_TRANSPARENT)
 			continue;
 		expandaliasvert(mesh->num_vertices);
-		vertices = R_Shadow_VertexBuffer(mesh->num_vertices);
-		R_Model_Alias_GetMesh_Vertex3f(ent, mesh, vertices, aliasvert_normal3f, aliasvert_svector3f, aliasvert_tvector3f);
+		R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, aliasvert_vertex3f);
+		R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_SVECTOR, aliasvert_svector3f);
+		R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_TVECTOR, aliasvert_tvector3f);
+		R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, aliasvert_normal3f);
 		for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
 		{
-			if (!(layer->flags & ALIASLAYER_DRAW_PER_LIGHT)
+			if (!(layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
 			 || ((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
 			 || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0))
 				continue;
@@ -498,7 +380,7 @@ void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 			if (layer->flags & ALIASLAYER_SPECULAR)
 			{
 				c_alias_polys += mesh->num_triangles;
-				R_Shadow_SpecularLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertices, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor2, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, NULL);
+				R_Shadow_RenderLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, aliasvert_vertex3f, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, layer->texture, lightcubemap, LIGHTING_SPECULAR);
 			}
 			else if (layer->flags & ALIASLAYER_DIFFUSE)
 			{
@@ -527,7 +409,7 @@ void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
 					lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
 				}
 				c_alias_polys += mesh->num_triangles;
-				R_Shadow_DiffuseLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertices, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, lightradius, lightcolor2, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, NULL);
+				R_Shadow_RenderLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, aliasvert_vertex3f, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, layer->texture, lightcubemap, LIGHTING_DIFFUSE);
 			}
 		}
 	}
@@ -795,7 +677,7 @@ void ZymoticCalcNormal3f(int vertcount, float *vertex3f, float *normal3f, int sh
 
 void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
 {
-	float fog, ifog, colorscale;
+	float fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
 	vec3_t diff;
 	int i, *renderlist, *elements;
 	rtexture_t *texture;
@@ -807,12 +689,12 @@ void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
 	R_Mesh_Matrix(&ent->matrix);
 
 	// find the vertex index list and texture
-	renderlist = ent->model->zymdata_renderlist;
+	renderlist = ent->model->alias.zymdata_renderlist;
 	for (i = 0;i < shadernum;i++)
 		renderlist += renderlist[0] * 3 + 1;
-	texture = ent->model->zymdata_textures[shadernum];
+	texture = ent->model->alias.zymdata_textures[shadernum];
 
-	numverts = ent->model->zymnum_verts;
+	numverts = ent->model->alias.zymnum_verts;
 	numtriangles = *renderlist++;
 	elements = renderlist;
 
@@ -821,7 +703,7 @@ void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
 	fog = 0;
 	if (fogenabled)
 	{
-		VectorSubtract(ent->origin, r_origin, diff);
+		VectorSubtract(ent->origin, r_vieworigin, diff);
 		fog = DotProduct(diff,diff);
 		if (fog < 0.01f)
 			fog = 0.01f;
@@ -836,52 +718,70 @@ void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
 	}
 	ifog = 1 - fog;
 
-	memset(&mstate, 0, sizeof(mstate));
 	if (ent->effects & EF_ADDITIVE)
 	{
-		mstate.blendfunc1 = GL_SRC_ALPHA;
-		mstate.blendfunc2 = GL_ONE;
+		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+		GL_DepthMask(false);
 	}
 	else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
 	{
-		mstate.blendfunc1 = GL_SRC_ALPHA;
-		mstate.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		GL_DepthMask(false);
 	}
 	else
 	{
-		mstate.blendfunc1 = GL_ONE;
-		mstate.blendfunc2 = GL_ZERO;
+		GL_BlendFunc(GL_ONE, GL_ZERO);
+		GL_DepthMask(true);
 	}
-	colorscale = r_colorscale;
+	GL_DepthTest(true);
+
+	memset(&mstate, 0, sizeof(mstate));
+	colorscale = 1.0f;
 	if (gl_combine.integer)
 	{
 		mstate.texrgbscale[0] = 4;
 		colorscale *= 0.25f;
 	}
 	mstate.tex[0] = R_GetTexture(texture);
-	R_Mesh_State(&mstate);
-	ZymoticLerpBones(ent->model->zymnum_bones, (zymbonematrix *) ent->model->zymdata_poses, ent->frameblend, ent->model->zymdata_bones);
+	mstate.pointer_texcoord[0] = ent->model->alias.zymdata_texcoords;
+	mstate.pointer_vertex = varray_vertex3f;
 
-	R_Mesh_GetSpace(numverts);
-	ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->zymdata_vertbonecounts, ent->model->zymdata_verts);
-	R_Mesh_CopyTexCoord2f(0, ent->model->zymdata_texcoords, ent->model->zymnum_verts);
-	ZymoticCalcNormal3f(numverts, varray_vertex3f, aliasvert_normal3f, ent->model->zymnum_shaders, ent->model->zymdata_renderlist);
-	R_LightModel(ent, numverts, varray_vertex3f, aliasvert_normal3f, varray_color4f, ifog * colorscale, ifog * colorscale, ifog * colorscale, false);
+	ZymoticLerpBones(ent->model->alias.zymnum_bones, (zymbonematrix *) ent->model->alias.zymdata_poses, ent->frameblend, ent->model->alias.zymdata_bones);
+
+	ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
+	ZymoticCalcNormal3f(numverts, varray_vertex3f, aliasvert_normal3f, ent->model->alias.zymnum_shaders, ent->model->alias.zymdata_renderlist);
+	if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, ifog * colorscale, ifog * colorscale, ifog * colorscale, ent->alpha, false))
+	{
+		mstate.pointer_color = varray_color4f;
+		R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, numverts, varray_vertex3f, aliasvert_normal3f, varray_color4f);
+	}
+	else
+		GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
+	R_Mesh_State(&mstate);
+	GL_LockArrays(0, numverts);
 	R_Mesh_Draw(numverts, numtriangles, elements);
+	GL_LockArrays(0, 0);
 	c_alias_polys += numtriangles;
 
 	if (fog)
 	{
+		GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		GL_DepthMask(false);
+		GL_DepthTest(true);
+
 		memset(&mstate, 0, sizeof(mstate));
-		mstate.blendfunc1 = GL_SRC_ALPHA;
-		mstate.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
 		// FIXME: need alpha mask for fogging...
 		//mstate.tex[0] = R_GetTexture(texture);
+		//mstate.pointer_texcoord = ent->model->alias.zymdata_texcoords;
+		mstate.pointer_vertex = varray_vertex3f;
+		R_Mesh_State(&mstate);
+
+		GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], ent->alpha * fog);
+		ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
 		R_Mesh_State(&mstate);
-		GL_Color(fogcolor[0] * r_colorscale, fogcolor[1] * r_colorscale, fogcolor[2] * r_colorscale, ent->alpha * fog);
-		R_Mesh_GetSpace(numverts);
-		ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->zymdata_vertbonecounts, ent->model->zymdata_verts);
+		GL_LockArrays(0, numverts);
 		R_Mesh_Draw(numverts, numtriangles, elements);
+		GL_LockArrays(0, 0);
 		c_alias_polys += numtriangles;
 	}
 }
@@ -895,26 +795,21 @@ void R_Model_Zymotic_Draw(entity_render_t *ent)
 
 	c_models++;
 
-	for (i = 0;i < ent->model->zymnum_shaders;i++)
+	for (i = 0;i < ent->model->alias.zymnum_shaders;i++)
 	{
-		if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->zymdata_textures[i]))
+		if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->alias.zymdata_textures[i]))
 			R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
 		else
 			R_DrawZymoticModelMeshCallback(ent, i);
 	}
 }
 
-void R_Model_Zymotic_DrawFakeShadow(entity_render_t *ent)
-{
-	// FIXME
-}
-
-void R_Model_Zymotic_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, float lightradius2, float lightdistbias, float lightsubtract, float *lightcolor)
+void R_Model_Zymotic_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
 {
 	// FIXME
 }
 
-void R_Model_Zymotic_DrawOntoLight(entity_render_t *ent)
+void R_Model_Zymotic_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
 {
 	// FIXME
 }