X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=model_alias.c;h=590ee02d77b55a25ba8f6b498addbda90966bf28;hp=d9827db113033785c424d57e9cb14f38d09b61d1;hb=ded16fd66f1a999d35ee57f989f881f205a428c7;hpb=cf16c53c338684106609a90407e889820fc18a76

diff --git a/model_alias.c b/model_alias.c
index d9827db1..590ee02d 100644
--- a/model_alias.c
+++ b/model_alias.c
@@ -29,40 +29,34 @@ cvar_t r_skeletal_debugtranslatex = {0, "r_skeletal_debugtranslatex", "1", "deve
 cvar_t r_skeletal_debugtranslatey = {0, "r_skeletal_debugtranslatey", "1", "development cvar for testing skeletal model code"};
 cvar_t r_skeletal_debugtranslatez = {0, "r_skeletal_debugtranslatez", "1", "development cvar for testing skeletal model code"};
 
+float mod_md3_sin[320];
+
 void Mod_AliasInit (void)
 {
+	int i;
 	Cvar_RegisterVariable(&r_skeletal_debugbone);
 	Cvar_RegisterVariable(&r_skeletal_debugbonecomponent);
 	Cvar_RegisterVariable(&r_skeletal_debugbonevalue);
 	Cvar_RegisterVariable(&r_skeletal_debugtranslatex);
 	Cvar_RegisterVariable(&r_skeletal_debugtranslatey);
 	Cvar_RegisterVariable(&r_skeletal_debugtranslatez);
+	for (i = 0;i < 320;i++)
+		mod_md3_sin[i] = sin(i * M_PI * 2.0f / 256.0);
 }
 
 void Mod_Alias_GetMesh_Vertices(const model_t *model, const frameblend_t *frameblend, float *vertex3f, float *normal3f, float *svector3f, float *tvector3f)
 {
+#define MAX_BONES 256
 	if (model->surfmesh.data_vertexweightindex4i)
 	{
-		int i, k, blends;
-		const float *v = model->surfmesh.data_vertex3f;
-		const float *n = model->surfmesh.data_normal3f;
-		const float *sv = model->surfmesh.data_svector3f;
-		const float *tv = model->surfmesh.data_tvector3f;
-		const int *wi = model->surfmesh.data_vertexweightindex4i;
-		const float *wf = model->surfmesh.data_vertexweightinfluence4f;
-		float *matrix, m[12], bonepose[256][12], boneposerelative[256][12];
 		// vertex weighted skeletal
-		memset(vertex3f, 0, model->surfmesh.num_vertices * sizeof(float[3]));
-		if (normal3f)
-			memset(normal3f, 0, model->surfmesh.num_vertices * sizeof(float[3]));
-		if (svector3f)
-		{
-			memset(svector3f, 0, model->surfmesh.num_vertices * sizeof(float[3]));
-			memset(tvector3f, 0, model->surfmesh.num_vertices * sizeof(float[3]));
-		}
+		int i, k;
+		float boneposerelative[MAX_BONES][12];
 		// interpolate matrices and concatenate them to their parents
 		for (i = 0;i < model->num_bones;i++)
 		{
+			int blends;
+			float *matrix, m[12], bonepose[MAX_BONES][12];
 			for (k = 0;k < 12;k++)
 				m[k] = 0;
 			for (blends = 0;blends < 4 && frameblend[blends].lerp > 0;blends++)
@@ -86,100 +80,278 @@ void Mod_Alias_GetMesh_Vertices(const model_t *model, const frameblend_t *frameb
 			R_ConcatTransforms(bonepose[i], model->data_baseboneposeinverse + i * 12, boneposerelative[i]);
 		}
 		// blend the vertex bone weights
-		if (svector3f)
+		// special case for the extremely common wf[0] == 1 because it saves 3 multiplies per array when compared to the other case (w[0] is always 1 if only one bone controls this vertex, artists only use multiple bones for certain special cases)
+		// special case for the first bone because it avoids the need to memset the arrays before filling
 		{
-			for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, n += 3, sv += 3, tv += 3, wi += 4, wf += 4, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3)
+			const float *v = model->surfmesh.data_vertex3f;
+			const int *wi = model->surfmesh.data_vertexweightindex4i;
+			const float *wf = model->surfmesh.data_vertexweightinfluence4f;
+			for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, wi += 4, wf += 4, vertex3f += 3)
 			{
-				for (k = 0;k < 4 && wf[k];k++)
+				if (wf[0] == 1)
 				{
-					const float *m = boneposerelative[wi[k]];
-					float f = wf[k];
-					vertex3f[0] += f * (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
-					vertex3f[1] += f * (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
-					vertex3f[2] += f * (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
-					normal3f[0] += f * (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
-					normal3f[1] += f * (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
-					normal3f[2] += f * (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
-					svector3f[0] += f * (sv[0] * m[0] + sv[1] * m[1] + sv[2] * m[ 2]);
-					svector3f[1] += f * (sv[0] * m[4] + sv[1] * m[5] + sv[2] * m[ 6]);
-					svector3f[2] += f * (sv[0] * m[8] + sv[1] * m[9] + sv[2] * m[10]);
-					tvector3f[0] += f * (tv[0] * m[0] + tv[1] * m[1] + tv[2] * m[ 2]);
-					tvector3f[1] += f * (tv[0] * m[4] + tv[1] * m[5] + tv[2] * m[ 6]);
-					tvector3f[2] += f * (tv[0] * m[8] + tv[1] * m[9] + tv[2] * m[10]);
+					const float *m = boneposerelative[wi[0]];
+					vertex3f[0] = (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
+					vertex3f[1] = (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
+					vertex3f[2] = (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+				}
+				else
+				{
+					const float *m = boneposerelative[wi[0]];
+					float f = wf[0];
+					vertex3f[0] = f * (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
+					vertex3f[1] = f * (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
+					vertex3f[2] = f * (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+					for (k = 1;k < 4 && wf[k];k++)
+					{
+						const float *m = boneposerelative[wi[k]];
+						float f = wf[k];
+						vertex3f[0] += f * (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
+						vertex3f[1] += f * (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
+						vertex3f[2] += f * (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+					}
 				}
 			}
 		}
-		else if (normal3f)
+		if (normal3f)
 		{
-			for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, n += 3, wi += 4, wf += 4, vertex3f += 3, normal3f += 3)
+			const float *n = model->surfmesh.data_normal3f;
+			const int *wi = model->surfmesh.data_vertexweightindex4i;
+			const float *wf = model->surfmesh.data_vertexweightinfluence4f;
+			for (i = 0;i < model->surfmesh.num_vertices;i++, n += 3, wi += 4, wf += 4, normal3f += 3)
 			{
-				for (k = 0;k < 4 && wf[k];k++)
+				if (wf[0] == 1)
 				{
-					const float *m = boneposerelative[wi[k]];
-					float f = wf[k];
-					vertex3f[0] += f * (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
-					vertex3f[1] += f * (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
-					vertex3f[2] += f * (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
-					normal3f[0] += f * (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
-					normal3f[1] += f * (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
-					normal3f[2] += f * (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+					const float *m = boneposerelative[wi[0]];
+					normal3f[0] = (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
+					normal3f[1] = (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
+					normal3f[2] = (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+				}
+				else
+				{
+					const float *m = boneposerelative[wi[0]];
+					float f = wf[0];
+					normal3f[0] = f * (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
+					normal3f[1] = f * (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
+					normal3f[2] = f * (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+					for (k = 1;k < 4 && wf[k];k++)
+					{
+						const float *m = boneposerelative[wi[k]];
+						float f = wf[k];
+						normal3f[0] += f * (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
+						normal3f[1] += f * (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
+						normal3f[2] += f * (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+					}
 				}
 			}
 		}
-		else
+		if (svector3f)
 		{
-			for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, wi += 4, wf += 4, vertex3f += 3)
+			const float *sv = model->surfmesh.data_svector3f;
+			const int *wi = model->surfmesh.data_vertexweightindex4i;
+			const float *wf = model->surfmesh.data_vertexweightinfluence4f;
+			for (i = 0;i < model->surfmesh.num_vertices;i++, sv += 3, wi += 4, wf += 4, svector3f += 3)
+			{
+				if (wf[0] == 1)
+				{
+					const float *m = boneposerelative[wi[0]];
+					svector3f[0] = (sv[0] * m[0] + sv[1] * m[1] + sv[2] * m[ 2]);
+					svector3f[1] = (sv[0] * m[4] + sv[1] * m[5] + sv[2] * m[ 6]);
+					svector3f[2] = (sv[0] * m[8] + sv[1] * m[9] + sv[2] * m[10]);
+				}
+				else
+				{
+					const float *m = boneposerelative[wi[0]];
+					float f = wf[0];
+					svector3f[0] = f * (sv[0] * m[0] + sv[1] * m[1] + sv[2] * m[ 2]);
+					svector3f[1] = f * (sv[0] * m[4] + sv[1] * m[5] + sv[2] * m[ 6]);
+					svector3f[2] = f * (sv[0] * m[8] + sv[1] * m[9] + sv[2] * m[10]);
+					for (k = 1;k < 4 && wf[k];k++)
+					{
+						const float *m = boneposerelative[wi[k]];
+						float f = wf[k];
+						svector3f[0] += f * (sv[0] * m[0] + sv[1] * m[1] + sv[2] * m[ 2]);
+						svector3f[1] += f * (sv[0] * m[4] + sv[1] * m[5] + sv[2] * m[ 6]);
+						svector3f[2] += f * (sv[0] * m[8] + sv[1] * m[9] + sv[2] * m[10]);
+					}
+				}
+			}
+		}
+		if (tvector3f)
+		{
+			const float *tv = model->surfmesh.data_tvector3f;
+			const int *wi = model->surfmesh.data_vertexweightindex4i;
+			const float *wf = model->surfmesh.data_vertexweightinfluence4f;
+			for (i = 0;i < model->surfmesh.num_vertices;i++, tv += 3, wi += 4, wf += 4, tvector3f += 3)
 			{
-				for (k = 0;k < 4 && wf[k];k++)
+				if (wf[0] == 1)
+				{
+					const float *m = boneposerelative[wi[0]];
+					tvector3f[0] = (tv[0] * m[0] + tv[1] * m[1] + tv[2] * m[ 2]);
+					tvector3f[1] = (tv[0] * m[4] + tv[1] * m[5] + tv[2] * m[ 6]);
+					tvector3f[2] = (tv[0] * m[8] + tv[1] * m[9] + tv[2] * m[10]);
+				}
+				else
 				{
-					const float *m = boneposerelative[wi[k]];
-					float f = wf[k];
-					vertex3f[0] += f * (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
-					vertex3f[1] += f * (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
-					vertex3f[2] += f * (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+					const float *m = boneposerelative[wi[0]];
+					float f = wf[0];
+					tvector3f[0] = f * (tv[0] * m[0] + tv[1] * m[1] + tv[2] * m[ 2]);
+					tvector3f[1] = f * (tv[0] * m[4] + tv[1] * m[5] + tv[2] * m[ 6]);
+					tvector3f[2] = f * (tv[0] * m[8] + tv[1] * m[9] + tv[2] * m[10]);
+					for (k = 1;k < 4 && wf[k];k++)
+					{
+						const float *m = boneposerelative[wi[k]];
+						float f = wf[k];
+						tvector3f[0] += f * (tv[0] * m[0] + tv[1] * m[1] + tv[2] * m[ 2]);
+						tvector3f[1] += f * (tv[0] * m[4] + tv[1] * m[5] + tv[2] * m[ 6]);
+						tvector3f[2] += f * (tv[0] * m[8] + tv[1] * m[9] + tv[2] * m[10]);
+					}
 				}
 			}
 		}
 	}
-	else if (model->surfmesh.data_morphvertex3f)
+	else if (model->surfmesh.data_morphmd3vertex)
 	{
 		// vertex morph
+		int i, numblends, blendnum;
 		int numverts = model->surfmesh.num_vertices;
-		const float *vertsbase = model->surfmesh.data_morphvertex3f;
-		const float *verts1 = vertsbase + numverts * 3 * frameblend[0].frame;
-		if (frameblend[1].lerp)
+		numblends = 0;
+		for (blendnum = 0;blendnum < 4;blendnum++)
 		{
-			int i;
-			float lerp1 = frameblend[0].lerp;
-			const float *verts2 = vertsbase + numverts * 3 * frameblend[1].frame;
-			float lerp2 = frameblend[1].lerp;
-			if (frameblend[2].lerp)
+			//VectorMA(translate, model->surfmesh.num_morphmdlframetranslate, frameblend[blendnum].lerp, translate);
+			if (frameblend[blendnum].lerp > 0)
+				numblends = blendnum + 1;
+		}
+		// special case for the first blend because it avoids some adds and the need to memset the arrays first
+		for (blendnum = 0;blendnum < numblends;blendnum++)
+		{
+			const md3vertex_t *verts = model->surfmesh.data_morphmd3vertex + numverts * frameblend[blendnum].frame;
+			float scale = frameblend[blendnum].lerp * (1.0f / 64.0f);
+			if (blendnum == 0)
 			{
-				const float *verts3 = vertsbase + numverts * 3 * frameblend[2].frame;
-				float lerp3 = frameblend[2].lerp;
-				if (frameblend[3].lerp)
+				for (i = 0;i < numverts;i++)
 				{
-					const float *verts4 = vertsbase + numverts * 3 * frameblend[3].frame;
-					float lerp4 = frameblend[3].lerp;
-					for (i = 0;i < numverts * 3;i++)
-						vertex3f[i] = lerp1 * verts1[i] + lerp2 * verts2[i] + lerp3 * verts3[i] + lerp4 * verts4[i];
+					vertex3f[i * 3 + 0] = verts[i].origin[0] * scale;
+					vertex3f[i * 3 + 1] = verts[i].origin[1] * scale;
+					vertex3f[i * 3 + 2] = verts[i].origin[2] * scale;
 				}
-				else
-					for (i = 0;i < numverts * 3;i++)
-						vertex3f[i] = lerp1 * verts1[i] + lerp2 * verts2[i] + lerp3 * verts3[i];
 			}
 			else
-				for (i = 0;i < numverts * 3;i++)
-					vertex3f[i] = lerp1 * verts1[i] + lerp2 * verts2[i];
+			{
+				for (i = 0;i < numverts;i++)
+				{
+					vertex3f[i * 3 + 0] += verts[i].origin[0] * scale;
+					vertex3f[i * 3 + 1] += verts[i].origin[1] * scale;
+					vertex3f[i * 3 + 2] += verts[i].origin[2] * scale;
+				}
+			}
+			// the yaw and pitch stored in md3 models are 8bit quantized angles
+			// (0-255), and as such a lookup table is very well suited to
+			// decoding them, and since cosine is equivilant to sine with an
+			// extra 45 degree rotation, this uses one lookup table for both
+			// sine and cosine with a +64 bias to get cosine.
+			if (normal3f)
+			{
+				float lerp = frameblend[blendnum].lerp;
+				if (blendnum == 0)
+				{
+					for (i = 0;i < numverts;i++)
+					{
+						normal3f[i * 3 + 0] = mod_md3_sin[verts[i].yaw + 64] * mod_md3_sin[verts[i].pitch     ] * lerp;
+						normal3f[i * 3 + 1] = mod_md3_sin[verts[i].yaw     ] * mod_md3_sin[verts[i].pitch     ] * lerp;
+						normal3f[i * 3 + 2] =                                  mod_md3_sin[verts[i].pitch + 64] * lerp;
+					}
+				}
+				else
+				{
+					for (i = 0;i < numverts;i++)
+					{
+						normal3f[i * 3 + 0] += mod_md3_sin[verts[i].yaw + 64] * mod_md3_sin[verts[i].pitch     ] * lerp;
+						normal3f[i * 3 + 1] += mod_md3_sin[verts[i].yaw     ] * mod_md3_sin[verts[i].pitch     ] * lerp;
+						normal3f[i * 3 + 2] +=                                  mod_md3_sin[verts[i].pitch + 64] * lerp;
+					}
+				}
+			}
 		}
-		else
-			memcpy(vertex3f, verts1, numverts * 3 * sizeof(float));
+		// md3 model vertices do not include tangents, so we have to generate them (extremely slow)
 		if (normal3f)
-		{
-			Mod_BuildNormals(0, model->surfmesh.num_vertices, model->surfmesh.num_triangles, vertex3f, model->surfmesh.data_element3i, normal3f, r_smoothnormals_areaweighting.integer);
 			if (svector3f)
 				Mod_BuildTextureVectorsFromNormals(0, model->surfmesh.num_vertices, model->surfmesh.num_triangles, vertex3f, model->surfmesh.data_texcoordtexture2f, normal3f, model->surfmesh.data_element3i, svector3f, tvector3f, r_smoothnormals_areaweighting.integer);
+	}
+	else if (model->surfmesh.data_morphmdlvertex)
+	{
+		// vertex morph
+		int i, numblends, blendnum;
+		int numverts = model->surfmesh.num_vertices;
+		float translate[3];
+		VectorClear(translate);
+		numblends = 0;
+		// blend the frame translates to avoid redundantly doing so on each vertex
+		// (a bit of a brain twister but it works)
+		for (blendnum = 0;blendnum < 4;blendnum++)
+		{
+			if (model->surfmesh.data_morphmd2framesize6f)
+				VectorMA(translate, frameblend[blendnum].lerp, model->surfmesh.data_morphmd2framesize6f + frameblend[blendnum].frame * 6 + 3, translate);
+			else
+				VectorMA(translate, frameblend[blendnum].lerp, model->surfmesh.num_morphmdlframetranslate, translate);
+			if (frameblend[blendnum].lerp > 0)
+				numblends = blendnum + 1;
 		}
+		// special case for the first blend because it avoids some adds and the need to memset the arrays first
+		for (blendnum = 0;blendnum < numblends;blendnum++)
+		{
+			const trivertx_t *verts = model->surfmesh.data_morphmdlvertex + numverts * frameblend[blendnum].frame;
+			float scale[3];
+			if (model->surfmesh.data_morphmd2framesize6f)
+				VectorScale(model->surfmesh.data_morphmd2framesize6f + frameblend[blendnum].frame * 6, frameblend[blendnum].lerp, scale);
+			else
+				VectorScale(model->surfmesh.num_morphmdlframescale, frameblend[blendnum].lerp, scale);
+			if (blendnum == 0)
+			{
+				for (i = 0;i < numverts;i++)
+				{
+					vertex3f[i * 3 + 0] = translate[0] + verts[i].v[0] * scale[0];
+					vertex3f[i * 3 + 1] = translate[1] + verts[i].v[1] * scale[1];
+					vertex3f[i * 3 + 2] = translate[2] + verts[i].v[2] * scale[2];
+				}
+			}
+			else
+			{
+				for (i = 0;i < numverts;i++)
+				{
+					vertex3f[i * 3 + 0] += verts[i].v[0] * scale[0];
+					vertex3f[i * 3 + 1] += verts[i].v[1] * scale[1];
+					vertex3f[i * 3 + 2] += verts[i].v[2] * scale[2];
+				}
+			}
+			// the vertex normals in mdl models are an index into a table of
+			// 162 unique values, this very crude quantization reduces the
+			// vertex normal to only one byte, which saves a lot of space but
+			// also makes lighting pretty coarse
+			if (normal3f)
+			{
+				float lerp = frameblend[blendnum].lerp;
+				if (blendnum == 0)
+				{
+					for (i = 0;i < numverts;i++)
+					{
+						const float *vn = m_bytenormals[verts[i].lightnormalindex];
+						VectorScale(vn, lerp, normal3f + i*3);
+					}
+				}
+				else
+				{
+					for (i = 0;i < numverts;i++)
+					{
+						const float *vn = m_bytenormals[verts[i].lightnormalindex];
+						VectorMA(normal3f + i*3, lerp, vn, normal3f + i*3);
+					}
+				}
+			}
+		}
+		if (normal3f)
+			if (svector3f)
+				Mod_BuildTextureVectorsFromNormals(0, model->surfmesh.num_vertices, model->surfmesh.num_triangles, vertex3f, model->surfmesh.data_texcoordtexture2f, normal3f, model->surfmesh.data_element3i, svector3f, tvector3f, r_smoothnormals_areaweighting.integer);
 	}
 	else
 		Host_Error("model %s has no skeletal or vertex morph animation data", model->name);
@@ -204,22 +376,7 @@ int Mod_Alias_GetTagMatrix(const model_t *model, int poseframe, int tagindex, ma
 			R_ConcatTransforms(boneframe + model->data_bones[tagindex].parent * 12, tempbonematrix, bonematrix);
 			tagindex = model->data_bones[tagindex].parent;
 		}
-		outmatrix->m[0][0] = bonematrix[0];
-		outmatrix->m[0][1] = bonematrix[1];
-		outmatrix->m[0][2] = bonematrix[2];
-		outmatrix->m[0][3] = bonematrix[3];
-		outmatrix->m[1][0] = bonematrix[4];
-		outmatrix->m[1][1] = bonematrix[5];
-		outmatrix->m[1][2] = bonematrix[6];
-		outmatrix->m[1][3] = bonematrix[7];
-		outmatrix->m[2][0] = bonematrix[8];
-		outmatrix->m[2][1] = bonematrix[9];
-		outmatrix->m[2][2] = bonematrix[10];
-		outmatrix->m[2][3] = bonematrix[11];
-		outmatrix->m[3][0] = 0;
-		outmatrix->m[3][1] = 0;
-		outmatrix->m[3][2] = 0;
-		outmatrix->m[3][3] = 1;
+		Matrix4x4_FromArray12FloatD3D(outmatrix, bonematrix);
 	}
 	else if (model->num_tags)
 	{
@@ -227,7 +384,7 @@ int Mod_Alias_GetTagMatrix(const model_t *model, int poseframe, int tagindex, ma
 			return 4;
 		if (poseframe >= model->num_tagframes)
 			return 6;
-		*outmatrix = model->data_tags[poseframe * model->num_tags + tagindex].matrix;
+		Matrix4x4_FromArray12FloatGL(outmatrix, model->data_tags[poseframe * model->num_tags + tagindex].matrixgl);
 	}
 	return 0;
 }
@@ -292,6 +449,66 @@ static void Mod_BuildBaseBonePoses(void)
 	}
 }
 
+static void Mod_Alias_CalculateBoundingBox(void)
+{
+	int i, j;
+	int vnum;
+	qboolean firstvertex = true;
+	float dist, yawradius, radius;
+	float *v;
+	float *vertex3f;
+	frameblend_t frameblend[4];
+	memset(frameblend, 0, sizeof(frameblend));
+	frameblend[0].lerp = 1;
+	vertex3f = Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+	VectorClear(loadmodel->normalmins);
+	VectorClear(loadmodel->normalmaxs);
+	yawradius = 0;
+	radius = 0;
+	for (i = 0;i < loadmodel->numframes;i++)
+	{
+		for (j = 0, frameblend[0].frame = loadmodel->animscenes[i].firstframe;j < loadmodel->animscenes[i].framecount;j++, frameblend[0].frame++)
+		{
+			Mod_Alias_GetMesh_Vertices(loadmodel, frameblend, vertex3f, NULL, NULL, NULL);
+			for (vnum = 0, v = vertex3f;vnum < loadmodel->surfmesh.num_vertices;vnum++, v += 3)
+			{
+				if (firstvertex)
+				{
+					firstvertex = false;
+					VectorCopy(v, loadmodel->normalmins);
+					VectorCopy(v, loadmodel->normalmaxs);
+				}
+				else
+				{
+					if (loadmodel->normalmins[0] > v[0]) loadmodel->normalmins[0] = v[0];
+					if (loadmodel->normalmins[1] > v[1]) loadmodel->normalmins[1] = v[1];
+					if (loadmodel->normalmins[2] > v[2]) loadmodel->normalmins[2] = v[2];
+					if (loadmodel->normalmaxs[0] < v[0]) loadmodel->normalmaxs[0] = v[0];
+					if (loadmodel->normalmaxs[1] < v[1]) loadmodel->normalmaxs[1] = v[1];
+					if (loadmodel->normalmaxs[2] < v[2]) loadmodel->normalmaxs[2] = v[2];
+				}
+				dist = v[0] * v[0] + v[1] * v[1];
+				if (yawradius < dist)
+					yawradius = dist;
+				dist += v[2] * v[2];
+				if (radius < dist)
+					radius = dist;
+			}
+		}
+	}
+	Mem_Free(vertex3f);
+	radius = sqrt(radius);
+	yawradius = sqrt(yawradius);
+	loadmodel->yawmins[0] = loadmodel->yawmins[1] = -yawradius;
+	loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = yawradius;
+	loadmodel->yawmins[2] = loadmodel->normalmins[2];
+	loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
+	loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -radius;
+	loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] = radius;
+	loadmodel->radius = radius;
+	loadmodel->radius2 = radius * radius;
+}
+
 static void Mod_Alias_Mesh_CompileFrameZero(void)
 {
 	frameblend_t frameblend[4] = {{0, 1}, {0, 0}, {0, 0}, {0, 0}};
@@ -299,9 +516,7 @@ static void Mod_Alias_Mesh_CompileFrameZero(void)
 	loadmodel->surfmesh.data_svector3f = loadmodel->surfmesh.data_vertex3f + loadmodel->surfmesh.num_vertices * 3;
 	loadmodel->surfmesh.data_tvector3f = loadmodel->surfmesh.data_vertex3f + loadmodel->surfmesh.num_vertices * 6;
 	loadmodel->surfmesh.data_normal3f = loadmodel->surfmesh.data_vertex3f + loadmodel->surfmesh.num_vertices * 9;
-	Mod_Alias_GetMesh_Vertices(loadmodel, frameblend, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL);
-	Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, true);
-	Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
+	Mod_Alias_GetMesh_Vertices(loadmodel, frameblend, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f);
 }
 
 static void Mod_MDLMD2MD3_TraceBox(model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
@@ -373,63 +588,23 @@ static void Mod_MDLMD2MD3_TraceBox(model_t *model, int frame, trace_t *trace, co
 	}
 }
 
-static void Mod_CalcAliasModelBBoxes (void)
-{
-	int vnum;
-	float dist, yawradius, radius;
-	float *v;
-	VectorClear(loadmodel->normalmins);
-	VectorClear(loadmodel->normalmaxs);
-	yawradius = 0;
-	radius = 0;
-	for (vnum = 0, v = loadmodel->surfmesh.data_morphvertex3f;vnum < loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes;vnum++, v += 3)
-	{
-		if (loadmodel->normalmins[0] > v[0]) loadmodel->normalmins[0] = v[0];
-		if (loadmodel->normalmins[1] > v[1]) loadmodel->normalmins[1] = v[1];
-		if (loadmodel->normalmins[2] > v[2]) loadmodel->normalmins[2] = v[2];
-		if (loadmodel->normalmaxs[0] < v[0]) loadmodel->normalmaxs[0] = v[0];
-		if (loadmodel->normalmaxs[1] < v[1]) loadmodel->normalmaxs[1] = v[1];
-		if (loadmodel->normalmaxs[2] < v[2]) loadmodel->normalmaxs[2] = v[2];
-		dist = v[0] * v[0] + v[1] * v[1];
-		if (yawradius < dist)
-			yawradius = dist;
-		dist += v[2] * v[2];
-		if (radius < dist)
-			radius = dist;
-	}
-	radius = sqrt(radius);
-	yawradius = sqrt(yawradius);
-	loadmodel->yawmins[0] = loadmodel->yawmins[1] = -yawradius;
-	loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = yawradius;
-	loadmodel->yawmins[2] = loadmodel->normalmins[2];
-	loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
-	loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -radius;
-	loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] = radius;
-	loadmodel->radius = radius;
-	loadmodel->radius2 = radius * radius;
-}
-
-static void Mod_ConvertAliasVerts (int inverts, vec3_t scale, vec3_t translate, trivertx_t *v, float *out3f, int *vertremap)
+static void Mod_ConvertAliasVerts (int inverts, trivertx_t *v, trivertx_t *out, int *vertremap)
 {
 	int i, j;
-	vec3_t temp;
 	for (i = 0;i < inverts;i++)
 	{
 		if (vertremap[i] < 0 && vertremap[i+inverts] < 0) // only used vertices need apply...
 			continue;
-		temp[0] = v[i].v[0] * scale[0] + translate[0];
-		temp[1] = v[i].v[1] * scale[1] + translate[1];
-		temp[2] = v[i].v[2] * scale[2] + translate[2];
 		j = vertremap[i]; // not onseam
 		if (j >= 0)
-			VectorCopy(temp, out3f + j * 3);
+			out[j] = v[i];
 		j = vertremap[i+inverts]; // onseam
 		if (j >= 0)
-			VectorCopy(temp, out3f + j * 3);
+			out[j] = v[i];
 	}
 }
 
-static void Mod_MDL_LoadFrames (unsigned char* datapointer, int inverts, vec3_t scale, vec3_t translate, int *vertremap)
+static void Mod_MDL_LoadFrames (unsigned char* datapointer, int inverts, int *vertremap)
 {
 	int i, f, pose, groupframes;
 	float interval;
@@ -472,7 +647,7 @@ static void Mod_MDL_LoadFrames (unsigned char* datapointer, int inverts, vec3_t
 		// get scene name from first frame
 		pinframe = (daliasframe_t *)datapointer;
 
-		strcpy(scene->name, pinframe->name);
+		strlcpy(scene->name, pinframe->name, sizeof(scene->name));
 		scene->firstframe = pose;
 		scene->framecount = groupframes;
 		scene->framerate = 1.0f / interval;
@@ -484,30 +659,32 @@ static void Mod_MDL_LoadFrames (unsigned char* datapointer, int inverts, vec3_t
 		{
 			pinframe = (daliasframe_t *)datapointer;
 			datapointer += sizeof(daliasframe_t);
-			Mod_ConvertAliasVerts(inverts, scale, translate, (trivertx_t *)datapointer, loadmodel->surfmesh.data_morphvertex3f + pose * loadmodel->surfmesh.num_vertices * 3, vertremap);
+			Mod_ConvertAliasVerts(inverts, (trivertx_t *)datapointer, loadmodel->surfmesh.data_morphmdlvertex + pose * loadmodel->surfmesh.num_vertices, vertremap);
 			datapointer += sizeof(trivertx_t) * inverts;
 			pose++;
 		}
 	}
 }
 
-static skinframe_t missingskinframe;
-static void Mod_BuildAliasSkinFromSkinFrame(texture_t *skin, skinframe_t *skinframe)
+static void Mod_BuildAliasSkinFromSkinFrame(texture_t *texture, skinframe_t *skinframe)
 {
-	// hack
-	if (skinframe == NULL)
+	texture->currentframe = texture;
+	texture->numskinframes = 1;
+	texture->skinframerate = 1;
+	texture->currentskinframe = texture->skinframes + 0;
+	if (skinframe)
+		texture->skinframes[0] = *skinframe;
+	else
 	{
-		skinframe = &missingskinframe;
-		memset(skinframe, 0, sizeof(*skinframe));
-		skinframe->base = r_texture_notexture;
+		// hack
+		memset(texture->skinframes, 0, sizeof(texture->skinframes));
+		texture->skinframes[0].base = r_texture_notexture;
 	}
 
-	skin->skin = *skinframe;
-	skin->currentframe = skin;
-	skin->basematerialflags = MATERIALFLAG_WALL;
-	if (skin->skin.fog)
-		skin->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT;
-	skin->currentmaterialflags = skin->basematerialflags;
+	texture->basematerialflags = MATERIALFLAG_WALL;
+	if (texture->currentskinframe->fog)
+		texture->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
+	texture->currentmaterialflags = texture->basematerialflags;
 }
 
 static void Mod_BuildAliasSkinsFromSkinFiles(texture_t *skin, skinfile_t *skinfile, char *meshname, char *shadername)
@@ -521,42 +698,30 @@ static void Mod_BuildAliasSkinsFromSkinFiles(texture_t *skin, skinfile_t *skinfi
 		for (i = 0;skinfile;skinfile = skinfile->next, i++, skin += loadmodel->num_surfaces)
 		{
 			memset(skin, 0, sizeof(*skin));
+			Mod_BuildAliasSkinFromSkinFrame(skin, NULL);
+			// don't render unmentioned meshes
+			skin->basematerialflags = skin->currentmaterialflags = 0;
+			// see if a mesh
 			for (skinfileitem = skinfile->items;skinfileitem;skinfileitem = skinfileitem->next)
 			{
 				// leave the skin unitialized (nodraw) if the replacement is "common/nodraw" or "textures/common/nodraw"
 				if (!strcmp(skinfileitem->name, meshname) && strcmp(skinfileitem->replacement, "common/nodraw") && strcmp(skinfileitem->replacement, "textures/common/nodraw"))
 				{
-					memset(&tempskinframe, 0, sizeof(tempskinframe));
-					if (Mod_LoadSkinFrame(&tempskinframe, skinfileitem->replacement, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
-						Mod_BuildAliasSkinFromSkinFrame(skin, &tempskinframe);
-					else
-					{
+					if (!Mod_LoadSkinFrame(&tempskinframe, skinfileitem->replacement, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
 						if (cls.state != ca_dedicated)
-							Con_Printf("mesh \"%s\": failed to load skin #%i \"%s\", falling back to mesh's internal shader name \"%s\"\n", meshname, i, skinfileitem->replacement, shadername);
-						if (Mod_LoadSkinFrame(&tempskinframe, shadername, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
-							Mod_BuildAliasSkinFromSkinFrame(skin, &tempskinframe);
-						else
-						{
-							if (cls.state != ca_dedicated)
-								Con_Printf("failed to load skin \"%s\"\n", shadername);
-							Mod_BuildAliasSkinFromSkinFrame(skin, NULL);
-						}
-					}
+							Con_Printf("mesh \"%s\": failed to load skin #%i \"%s\"\n", meshname, i, skinfileitem->replacement);
+					Mod_BuildAliasSkinFromSkinFrame(skin, &tempskinframe);
+					break;
 				}
 			}
 		}
 	}
 	else
 	{
-		memset(&tempskinframe, 0, sizeof(tempskinframe));
-		if (Mod_LoadSkinFrame(&tempskinframe, shadername, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
-			Mod_BuildAliasSkinFromSkinFrame(skin, &tempskinframe);
-		else
-		{
+		if (!Mod_LoadSkinFrame(&tempskinframe, shadername, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
 			if (cls.state != ca_dedicated)
 				Con_Printf("Can't find texture \"%s\" for mesh \"%s\", using grey checkerboard\n", shadername, meshname);
-			Mod_BuildAliasSkinFromSkinFrame(skin, NULL);
-		}
+		Mod_BuildAliasSkinFromSkinFrame(skin, &tempskinframe);
 	}
 }
 
@@ -565,7 +730,7 @@ static void Mod_BuildAliasSkinsFromSkinFiles(texture_t *skin, skinfile_t *skinfi
 void Mod_IDP0_Load(model_t *mod, void *buffer, void *bufferend)
 {
 	int i, j, version, totalskins, skinwidth, skinheight, groupframes, groupskins, numverts;
-	float scales, scalet, scale[3], translate[3], interval;
+	float scales, scalet, interval;
 	msurface_t *surface;
 	unsigned char *data;
 	mdl_t *pinmodel;
@@ -627,8 +792,8 @@ void Mod_IDP0_Load(model_t *mod, void *buffer, void *bufferend)
 
 	for (i = 0;i < 3;i++)
 	{
-		scale[i] = LittleFloat (pinmodel->scale[i]);
-		translate[i] = LittleFloat (pinmodel->scale_origin[i]);
+		loadmodel->surfmesh.num_morphmdlframescale[i] = LittleFloat (pinmodel->scale[i]);
+		loadmodel->surfmesh.num_morphmdlframetranslate[i] = LittleFloat (pinmodel->scale_origin[i]);
 	}
 
 	startskins = datapointer;
@@ -750,11 +915,11 @@ void Mod_IDP0_Load(model_t *mod, void *buffer, void *bufferend)
 
 // load the frames
 	loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numframes);
-	loadmodel->surfmesh.data_morphvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * loadmodel->surfmesh.num_morphframes * loadmodel->surfmesh.num_vertices);
+	loadmodel->surfmesh.data_morphmdlvertex = (trivertx_t *)Mem_Alloc(loadmodel->mempool, sizeof(trivertx_t) * loadmodel->surfmesh.num_morphframes * loadmodel->surfmesh.num_vertices);
 	loadmodel->surfmesh.data_neighbor3i = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_triangles * sizeof(int[3]));
-	Mod_MDL_LoadFrames (startframes, numverts, scale, translate, vertremap);
+	Mod_MDL_LoadFrames (startframes, numverts, vertremap);
 	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
-	Mod_CalcAliasModelBBoxes();
+	Mod_Alias_CalculateBoundingBox();
 	Mod_Alias_Mesh_CompileFrameZero();
 
 	Mem_Free(vertst);
@@ -845,7 +1010,7 @@ void Mod_IDP0_Load(model_t *mod, void *buffer, void *bufferend)
 
 			// store the info about the new skin
 			Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures + totalskins * loadmodel->num_surfaces, &tempskinframe);
-			strcpy(loadmodel->skinscenes[loadmodel->numskins].name, name);
+			strlcpy(loadmodel->skinscenes[loadmodel->numskins].name, name, sizeof(loadmodel->skinscenes[loadmodel->numskins].name));
 			loadmodel->skinscenes[loadmodel->numskins].firstframe = totalskins;
 			loadmodel->skinscenes[loadmodel->numskins].framecount = 1;
 			loadmodel->skinscenes[loadmodel->numskins].framerate = 10.0f;
@@ -863,25 +1028,14 @@ void Mod_IDP0_Load(model_t *mod, void *buffer, void *bufferend)
 	surface->num_triangles = loadmodel->surfmesh.num_triangles;
 	surface->num_firstvertex = 0;
 	surface->num_vertices = loadmodel->surfmesh.num_vertices;
-}
 
-static void Mod_MD2_ConvertVerts (vec3_t scale, vec3_t translate, trivertx_t *v, float *out3f, int numverts, int *vertremap)
-{
-	int i;
-	trivertx_t *in;
-	for (i = 0;i < numverts;i++, out3f += 3)
-	{
-		in = v + vertremap[i];
-		out3f[0] = in->v[0] * scale[0] + translate[0];
-		out3f[1] = in->v[1] * scale[1] + translate[1];
-		out3f[2] = in->v[2] * scale[2] + translate[2];
-	}
+	loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
 }
 
 void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 {
-	int i, j, k, hashindex, num, numxyz, numst, xyz, st, skinwidth, skinheight, *vertremap, version, end, numverts;
-	float *stverts, s, t, scale[3], translate[3];
+	int i, j, hashindex, numxyz, numst, xyz, st, skinwidth, skinheight, *vertremap, version, end;
+	float iskinwidth, iskinheight;
 	unsigned char *data;
 	msurface_t *surface;
 	md2_t *pinmodel;
@@ -893,8 +1047,8 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 	struct md2verthash_s
 	{
 		struct md2verthash_s *next;
-		int xyz;
-		float st[2];
+		unsigned short xyz;
+		unsigned short st;
 	}
 	*hash, **md2verthash, *md2verthashdata;
 	skinframe_t tempskinframe;
@@ -937,20 +1091,27 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 	if (LittleLong(pinmodel->ofs_glcmds) <= 0 || LittleLong(pinmodel->ofs_glcmds) >= end)
 		Host_Error ("%s is not a valid model", loadmodel->name);
 
-	loadmodel->num_surfaces = 1;
-	loadmodel->nummodelsurfaces = loadmodel->num_surfaces;
-	data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int));
-	loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
-	loadmodel->surfacelist = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
-	loadmodel->surfacelist[0] = 0;
-
 	loadmodel->numskins = LittleLong(pinmodel->num_skins);
 	numxyz = LittleLong(pinmodel->num_xyz);
 	numst = LittleLong(pinmodel->num_st);
 	loadmodel->surfmesh.num_triangles = LittleLong(pinmodel->num_tris);
 	loadmodel->numframes = LittleLong(pinmodel->num_frames);
 	loadmodel->surfmesh.num_morphframes = loadmodel->numframes;
-	loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, loadmodel->numframes * sizeof(animscene_t));
+	skinwidth = LittleLong(pinmodel->skinwidth);
+	skinheight = LittleLong(pinmodel->skinheight);
+	iskinwidth = 1.0f / skinwidth;
+	iskinheight = 1.0f / skinheight;
+
+	loadmodel->num_surfaces = 1;
+	loadmodel->nummodelsurfaces = loadmodel->num_surfaces;
+	data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->numframes * sizeof(animscene_t) + loadmodel->numframes * sizeof(float[6]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]));
+	loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
+	loadmodel->surfacelist = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
+	loadmodel->surfacelist[0] = 0;
+	loadmodel->animscenes = (animscene_t *)data;data += loadmodel->numframes * sizeof(animscene_t);
+	loadmodel->surfmesh.data_morphmd2framesize6f = (float *)data;data += loadmodel->numframes * sizeof(float[6]);
+	loadmodel->surfmesh.data_element3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
+	loadmodel->surfmesh.data_neighbor3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
 
 	loadmodel->flags = 0; // there are no MD2 flags
 	loadmodel->synctype = ST_RAND;
@@ -972,13 +1133,9 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 		loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
 		for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME)
 		{
-			if (Mod_LoadSkinFrame(&tempskinframe, inskin, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
-				Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures + i * loadmodel->num_surfaces, &tempskinframe);
-			else
-			{
+			if (!Mod_LoadSkinFrame(&tempskinframe, inskin, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, true, true))
 				Con_Printf("%s is missing skin \"%s\"\n", loadmodel->name, inskin);
-				Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures + i * loadmodel->num_surfaces, NULL);
-			}
+			Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures + i * loadmodel->num_surfaces, &tempskinframe);
 		}
 	}
 	else
@@ -1002,31 +1159,10 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 	// load the triangles and stvert data
 	inst = (unsigned short *)(base + LittleLong(pinmodel->ofs_st));
 	intri = (md2triangle_t *)(base + LittleLong(pinmodel->ofs_tris));
-	skinwidth = LittleLong(pinmodel->skinwidth);
-	skinheight = LittleLong(pinmodel->skinheight);
-
-	stverts = (float *)Mem_Alloc(tempmempool, numst * sizeof(float[2]));
-	s = 1.0f / skinwidth;
-	t = 1.0f / skinheight;
-	for (i = 0;i < numst;i++)
-	{
-		j = (unsigned short) LittleShort(inst[i*2+0]);
-		k = (unsigned short) LittleShort(inst[i*2+1]);
-		if (j >= skinwidth || k >= skinheight)
-		{
-			Con_Printf("%s has an invalid skin coordinate (%i %i) on vert %i, changing to 0 0\n", loadmodel->name, j, k, i);
-			j = 0;
-			k = 0;
-		}
-		stverts[i*2+0] = j * s;
-		stverts[i*2+1] = k * t;
-	}
-
-	md2verthash = (struct md2verthash_s **)Mem_Alloc(tempmempool, 256 * sizeof(hash));
+	md2verthash = (struct md2verthash_s **)Mem_Alloc(tempmempool, 65536 * sizeof(hash));
 	md2verthashdata = (struct md2verthash_s *)Mem_Alloc(tempmempool, loadmodel->surfmesh.num_triangles * 3 * sizeof(*hash));
 	// swap the triangle list
-	num = 0;
-	loadmodel->surfmesh.data_element3i = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_triangles * sizeof(int[3]));
+	loadmodel->surfmesh.num_vertices = 0;
 	for (i = 0;i < loadmodel->surfmesh.num_triangles;i++)
 	{
 		for (j = 0;j < 3;j++)
@@ -1043,18 +1179,15 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 				Con_Printf("%s has an invalid st index (%i) on triangle %i, resetting to 0\n", loadmodel->name, st, i);
 				st = 0;
 			}
-			s = stverts[st*2+0];
-			t = stverts[st*2+1];
-			hashindex = (xyz * 17 + st) & 255;
+			hashindex = (xyz * 256 + st) & 65535;
 			for (hash = md2verthash[hashindex];hash;hash = hash->next)
-				if (hash->xyz == xyz && hash->st[0] == s && hash->st[1] == t)
+				if (hash->xyz == xyz && hash->st == st)
 					break;
 			if (hash == NULL)
 			{
-				hash = md2verthashdata + num++;
+				hash = md2verthashdata + loadmodel->surfmesh.num_vertices++;
 				hash->xyz = xyz;
-				hash->st[0] = s;
-				hash->st[1] = t;
+				hash->st = st;
 				hash->next = md2verthash[hashindex];
 				md2verthash[hashindex] = hash;
 			}
@@ -1062,18 +1195,25 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 		}
 	}
 
-	Mem_Free(stverts);
-
-	numverts = num;
-	loadmodel->surfmesh.num_vertices = numverts;
-	vertremap = (int *)Mem_Alloc(loadmodel->mempool, num * sizeof(int));
-	loadmodel->surfmesh.data_texcoordtexture2f = (float *)Mem_Alloc(loadmodel->mempool, num * sizeof(float[2]));
-	for (i = 0;i < num;i++)
+	vertremap = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(int));
+	data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(float[2]) + loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t));
+	loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+	loadmodel->surfmesh.data_morphmdlvertex = (trivertx_t *)data;data += loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t);
+	for (i = 0;i < loadmodel->surfmesh.num_vertices;i++)
 	{
+		int sts, stt;
 		hash = md2verthashdata + i;
 		vertremap[i] = hash->xyz;
-		loadmodel->surfmesh.data_texcoordtexture2f[i*2+0] = hash->st[0];
-		loadmodel->surfmesh.data_texcoordtexture2f[i*2+1] = hash->st[1];
+		sts = LittleShort(inst[hash->st*2+0]);
+		stt = LittleShort(inst[hash->st*2+1]);
+		if (sts < 0 || sts >= skinwidth || stt < 0 || stt >= skinheight)
+		{
+			Con_Printf("%s has an invalid skin coordinate (%i %i) on vert %i, changing to 0 0\n", loadmodel->name, sts, stt, i);
+			sts = 0;
+			stt = 0;
+		}
+		loadmodel->surfmesh.data_texcoordtexture2f[i*2+0] = sts * iskinwidth;
+		loadmodel->surfmesh.data_texcoordtexture2f[i*2+1] = stt * iskinheight;
 	}
 
 	Mem_Free(md2verthash);
@@ -1081,20 +1221,27 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 
 	// load the frames
 	datapointer = (base + LittleLong(pinmodel->ofs_frames));
-	loadmodel->surfmesh.data_morphvertex3f = (float *)Mem_Alloc(loadmodel->mempool, numverts * loadmodel->surfmesh.num_morphframes * sizeof(float[3]));
 	for (i = 0;i < loadmodel->surfmesh.num_morphframes;i++)
 	{
+		int k;
+		trivertx_t *v;
+		trivertx_t *out;
 		pinframe = (md2frame_t *)datapointer;
 		datapointer += sizeof(md2frame_t);
+		// store the frame scale/translate into the appropriate array
 		for (j = 0;j < 3;j++)
 		{
-			scale[j] = LittleFloat(pinframe->scale[j]);
-			translate[j] = LittleFloat(pinframe->translate[j]);
+			loadmodel->surfmesh.data_morphmd2framesize6f[i*6+j] = LittleFloat(pinframe->scale[j]);
+			loadmodel->surfmesh.data_morphmd2framesize6f[i*6+3+j] = LittleFloat(pinframe->translate[j]);
 		}
-		Mod_MD2_ConvertVerts(scale, translate, (trivertx_t *)datapointer, loadmodel->surfmesh.data_morphvertex3f + i * numverts * 3, numverts, vertremap);
+		// convert the vertices
+		v = (trivertx_t *)datapointer;
+		out = loadmodel->surfmesh.data_morphmdlvertex + i * loadmodel->surfmesh.num_vertices;
+		for (k = 0;k < loadmodel->surfmesh.num_vertices;k++)
+			out[k] = v[vertremap[k]];
 		datapointer += numxyz * sizeof(trivertx_t);
 
-		strcpy(loadmodel->animscenes[i].name, pinframe->name);
+		strlcpy(loadmodel->animscenes[i].name, pinframe->name, sizeof(loadmodel->animscenes[i].name));
 		loadmodel->animscenes[i].firstframe = i;
 		loadmodel->animscenes[i].framecount = 1;
 		loadmodel->animscenes[i].framerate = 10;
@@ -1103,9 +1250,8 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 
 	Mem_Free(vertremap);
 
-	loadmodel->surfmesh.data_neighbor3i = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_triangles * sizeof(int[3]));
 	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
-	Mod_CalcAliasModelBBoxes();
+	Mod_Alias_CalculateBoundingBox();
 	Mod_Alias_Mesh_CompileFrameZero();
 
 	surface = loadmodel->data_surfaces;
@@ -1114,6 +1260,8 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
 	surface->num_triangles = loadmodel->surfmesh.num_triangles;
 	surface->num_firstvertex = 0;
 	surface->num_vertices = loadmodel->surfmesh.num_vertices;
+
+	loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
 }
 
 void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
@@ -1168,7 +1316,7 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
 	loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, loadmodel->numframes * sizeof(animscene_t));
 	for (i = 0, pinframe = (md3frameinfo_t *)((unsigned char *)pinmodel + LittleLong(pinmodel->lump_frameinfo));i < loadmodel->numframes;i++, pinframe++)
 	{
-		strcpy(loadmodel->animscenes[i].name, pinframe->name);
+		strlcpy(loadmodel->animscenes[i].name, pinframe->name, sizeof(loadmodel->animscenes[i].name));
 		loadmodel->animscenes[i].firstframe = i;
 		loadmodel->animscenes[i].framecount = 1;
 		loadmodel->animscenes[i].framerate = 10;
@@ -1181,14 +1329,11 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
 	loadmodel->data_tags = (aliastag_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_tagframes * loadmodel->num_tags * sizeof(aliastag_t));
 	for (i = 0, pintag = (md3tag_t *)((unsigned char *)pinmodel + LittleLong(pinmodel->lump_tags));i < loadmodel->num_tagframes * loadmodel->num_tags;i++, pintag++)
 	{
-		strcpy(loadmodel->data_tags[i].name, pintag->name);
-		loadmodel->data_tags[i].matrix = identitymatrix;
+		strlcpy(loadmodel->data_tags[i].name, pintag->name, sizeof(loadmodel->data_tags[i].name));
+		for (j = 0;j < 9;j++)
+			loadmodel->data_tags[i].matrixgl[j] = LittleFloat(pintag->rotationmatrix[j]);
 		for (j = 0;j < 3;j++)
-		{
-			for (k = 0;k < 3;k++)
-				loadmodel->data_tags[i].matrix.m[j][k] = LittleFloat(pintag->rotationmatrix[k * 3 + j]);
-			loadmodel->data_tags[i].matrix.m[j][3] = LittleFloat(pintag->origin[j]);
-		}
+			loadmodel->data_tags[i].matrixgl[9+j] = LittleFloat(pintag->origin[j]);
 		//Con_Printf("model \"%s\" frame #%i tag #%i \"%s\"\n", loadmodel->name, i / loadmodel->num_tags, i % loadmodel->num_tags, loadmodel->data_tags[i].name);
 	}
 
@@ -1207,7 +1352,7 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
 
 	loadmodel->nummodelsurfaces = loadmodel->num_surfaces;
 	loadmodel->num_textures = loadmodel->num_surfaces;
-	data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t) + meshtriangles * sizeof(int[3]) + meshtriangles * sizeof(int[3]) + meshvertices * sizeof(float[2]) + meshvertices * loadmodel->numframes * sizeof(float[3]));
+	data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t) + meshtriangles * sizeof(int[3]) + meshtriangles * sizeof(int[3]) + meshvertices * sizeof(float[2]) + meshvertices * loadmodel->numframes * sizeof(md3vertex_t));
 	loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
 	loadmodel->surfacelist = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
 	loadmodel->data_textures = (texture_t *)data;data += loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t);
@@ -1217,7 +1362,7 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
 	loadmodel->surfmesh.data_element3i = (int *)data;data += meshtriangles * sizeof(int[3]);
 	loadmodel->surfmesh.data_neighbor3i = (int *)data;data += meshtriangles * sizeof(int[3]);
 	loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += meshvertices * sizeof(float[2]);
-	loadmodel->surfmesh.data_morphvertex3f = (float *)data;data += meshvertices * loadmodel->numframes * sizeof(float[3]);
+	loadmodel->surfmesh.data_morphmd3vertex = (md3vertex_t *)data;data += meshvertices * loadmodel->numframes * sizeof(md3vertex_t);
 
 	meshvertices = 0;
 	meshtriangles = 0;
@@ -1244,13 +1389,15 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
 		}
 		for (j = 0;j < loadmodel->numframes;j++)
 		{
-			const short *in4s = (short *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_framevertices)) + j * surface->num_vertices * 4;
-			float *out3f = loadmodel->surfmesh.data_morphvertex3f + 3 * (j * loadmodel->surfmesh.num_vertices + surface->num_firstvertex);
-			for (k = 0;k < surface->num_vertices;k++, in4s += 4, out3f += 3)
+			const md3vertex_t *in = (md3vertex_t *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_framevertices)) + j * surface->num_vertices;
+			md3vertex_t *out = loadmodel->surfmesh.data_morphmd3vertex + surface->num_firstvertex + j * loadmodel->surfmesh.num_vertices;
+			for (k = 0;k < surface->num_vertices;k++, in++, out++)
 			{
-				out3f[0] = LittleShort(in4s[0]) * (1.0f / 64.0f);
-				out3f[1] = LittleShort(in4s[1]) * (1.0f / 64.0f);
-				out3f[2] = LittleShort(in4s[2]) * (1.0f / 64.0f);
+				out->origin[0] = LittleShort(in->origin[0]);
+				out->origin[1] = LittleShort(in->origin[1]);
+				out->origin[2] = LittleShort(in->origin[2]);
+				out->pitch = in->pitch;
+				out->yaw = in->yaw;
 			}
 		}
 
@@ -1264,8 +1411,10 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
 	}
 	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
 	Mod_Alias_Mesh_CompileFrameZero();
-	Mod_CalcAliasModelBBoxes();
+	Mod_Alias_CalculateBoundingBox();
 	Mod_FreeSkinFiles(skinfiles);
+
+	loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
 }
 
 void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer, void *bufferend)
@@ -1285,7 +1434,7 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	pinmodel = (zymtype1header_t *)buffer;
 	pbase = (unsigned char *)buffer;
 	if (memcmp(pinmodel->id, "ZYMOTICMODEL", 12))
-		Host_Error ("Mod_ZYMOTICMODEL_Load: %s is not a zymotic model");
+		Host_Error ("Mod_ZYMOTICMODEL_Load: %s is not a zymotic model", loadmodel->name);
 	if (BigLong(pinmodel->type) != 1)
 		Host_Error ("Mod_ZYMOTICMODEL_Load: only type 1 (skeletal pose) models are currently supported (name = %s)", loadmodel->name);
 
@@ -1330,12 +1479,12 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 
 	if (pheader->numtris < 1 || pheader->numverts < 3 || pheader->numshaders < 1)
 	{
-		Con_Printf("%s has no geometry\n");
+		Con_Printf("%s has no geometry\n", loadmodel->name);
 		return;
 	}
 	if (pheader->numscenes < 1 || pheader->lump_poses.length < (int)sizeof(float[3][4]))
 	{
-		Con_Printf("%s has no animations\n");
+		Con_Printf("%s has no animations\n", loadmodel->name);
 		return;
 	}
 
@@ -1576,6 +1725,8 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, true);
 	Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
 	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
+
+	loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
 }
 
 void Mod_DARKPLACESMODEL_Load(model_t *mod, void *buffer, void *bufferend)
@@ -1593,7 +1744,7 @@ void Mod_DARKPLACESMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	pheader = (dpmheader_t *)buffer;
 	pbase = (unsigned char *)buffer;
 	if (memcmp(pheader->id, "DARKPLACESMODEL\0", 16))
-		Host_Error ("Mod_DARKPLACESMODEL_Load: %s is not a darkplaces model");
+		Host_Error ("Mod_DARKPLACESMODEL_Load: %s is not a darkplaces model", loadmodel->name);
 	if (BigLong(pheader->type) != 2)
 		Host_Error ("Mod_DARKPLACESMODEL_Load: only type 2 (hierarchical skeletal pose) models are currently supported (name = %s)", loadmodel->name);
 
@@ -1621,12 +1772,12 @@ void Mod_DARKPLACESMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 
 	if (pheader->num_bones < 1 || pheader->num_meshs < 1)
 	{
-		Con_Printf("%s has no geometry\n");
+		Con_Printf("%s has no geometry\n", loadmodel->name);
 		return;
 	}
 	if (pheader->num_frames < 1)
 	{
-		Con_Printf("%s has no frames\n");
+		Con_Printf("%s has no frames\n", loadmodel->name);
 		return;
 	}
 
@@ -1866,15 +2017,8 @@ void Mod_DARKPLACESMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	Mod_BuildBaseBonePoses();
 	Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
 	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
-}
 
-static void Mod_PSKMODEL_AnimKeyToMatrix(float *origin, float *quat, matrix4x4_t *m)
-{
-	float x = quat[0], y = quat[1], z = quat[2], w = quat[3];
-	m->m[0][0]=1-2*(y*y+z*z);m->m[0][1]=  2*(x*y-z*w);m->m[0][2]=  2*(x*z+y*w);m->m[0][3]=origin[0];
-	m->m[1][0]=  2*(x*y+z*w);m->m[1][1]=1-2*(x*x+z*z);m->m[1][2]=  2*(y*z-x*w);m->m[1][3]=origin[1];
-	m->m[2][0]=  2*(x*z-y*w);m->m[2][1]=  2*(y*z+x*w);m->m[2][2]=1-2*(x*x+y*y);m->m[2][3]=origin[2];
-	m->m[3][0]=  0          ;m->m[3][1]=  0          ;m->m[3][2]=  0          ;m->m[3][3]=1;
+	loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
 }
 
 // no idea why PSK/PSA files contain weird quaternions but they do...
@@ -1901,7 +2045,7 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 
 	pchunk = (pskchunk_t *)buffer;
 	if (strcmp(pchunk->id, "ACTRHEAD"))
-		Host_Error ("Mod_PSKMODEL_Load: %s is not an Unreal Engine ActorX (.psk + .psa) model");
+		Host_Error ("Mod_PSKMODEL_Load: %s is not an Unreal Engine ActorX (.psk + .psa) model", loadmodel->name);
 
 	loadmodel->type = mod_alias;
 	loadmodel->DrawSky = NULL;
@@ -2031,6 +2175,7 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 			matts = (pskmatt_t *)buffer;
 			for (index = 0, p = (pskmatt_t *)buffer;index < numrecords;index++, p++)
 			{
+				// nothing to do
 			}
 			buffer = p;
 		}
@@ -2135,7 +2280,7 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 			// positions from the psk, but this is hard for me to implement
 			// and people can easily make animations that match.
 			if (numanimbones != numbones)
-				Host_Error("%s: this loader only supports animations with the same bones as the mesh");
+				Host_Error("%s: this loader only supports animations with the same bones as the mesh", loadmodel->name);
 			for (index = 0, p = (pskboneinfo_t *)animbuffer;index < numrecords;index++, p++)
 			{
 				p->numchildren = LittleLong(p->numchildren);
@@ -2192,9 +2337,7 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 				p->firstframe = LittleLong(p->firstframe);
 				p->numframes = LittleLong(p->numframes);
 				if (p->numbones != numbones)
-				{
 					Con_Printf("%s: animinfo->numbones != numbones, trying to load anyway!\n", animname);
-				}
 			}
 			animbuffer = p;
 		}
@@ -2240,20 +2383,6 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	if (!numpnts || !pnts || !numvtxw || !vtxw || !numfaces || !faces || !nummatts || !matts || !numbones || !bones || !numrawweights || !rawweights || !numanims || !anims || !numanimkeys || !animkeys)
 		Host_Error("%s: missing required chunks", loadmodel->name);
 
-	// FIXME: model bbox
-	// model bbox
-	for (i = 0;i < 3;i++)
-	{
-		loadmodel->normalmins[i] = -128;
-		loadmodel->normalmaxs[i] = 128;
-		loadmodel->yawmins[i] = -128;
-		loadmodel->yawmaxs[i] = 128;
-		loadmodel->rotatedmins[i] = -128;
-		loadmodel->rotatedmaxs[i] = 128;
-	}
-	loadmodel->radius = 128;
-	loadmodel->radius2 = loadmodel->radius * loadmodel->radius;
-
 	loadmodel->numframes = 0;
 	for (index = 0;index < numanims;index++)
 		loadmodel->numframes += anims[index].numframes;
@@ -2411,20 +2540,10 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	// load the poses from the animkeys
 	for (index = 0;index < numanimkeys;index++)
 	{
+		pskanimkeys_t *k = animkeys + index;
 		matrix4x4_t matrix;
-		Mod_PSKMODEL_AnimKeyToMatrix(animkeys[index].origin, animkeys[index].quat, &matrix);
-		loadmodel->data_poses[index*12+0] = matrix.m[0][0];
-		loadmodel->data_poses[index*12+1] = matrix.m[0][1];
-		loadmodel->data_poses[index*12+2] = matrix.m[0][2];
-		loadmodel->data_poses[index*12+3] = matrix.m[0][3];
-		loadmodel->data_poses[index*12+4] = matrix.m[1][0];
-		loadmodel->data_poses[index*12+5] = matrix.m[1][1];
-		loadmodel->data_poses[index*12+6] = matrix.m[1][2];
-		loadmodel->data_poses[index*12+7] = matrix.m[1][3];
-		loadmodel->data_poses[index*12+8] = matrix.m[2][0];
-		loadmodel->data_poses[index*12+9] = matrix.m[2][1];
-		loadmodel->data_poses[index*12+10] = matrix.m[2][2];
-		loadmodel->data_poses[index*12+11] = matrix.m[2][3];
+		Matrix4x4_FromOriginQuat(&matrix, k->origin[0], k->origin[1], k->origin[2], k->quat[0], k->quat[1], k->quat[2], k->quat[3]);
+		Matrix4x4_ToArray12FloatD3D(&matrix, loadmodel->data_poses + index*12);
 	}
 	Mod_FreeSkinFiles(skinfiles);
 	Mem_Free(animfilebuffer);
@@ -2436,5 +2555,8 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
 	Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, true);
 	Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
 	Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
+	Mod_Alias_CalculateBoundingBox();
+
+	loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
 }