attempt to support quakeforge 16bit mdl variant. untested.

Quake/gl_mesh.c

@@ -107,11 +107,28 @@ void GL_MakeAliasModelDisplayLists (qmodel_t *m, aliashdr_t *paliashdr)
 		}
 	}
 
+	switch(paliashdr->poseverttype)
+	{
+	case PV_QUAKEFORGE:
+		verts = (trivertx_t *) Hunk_Alloc (paliashdr->numposes * paliashdr->numverts_vbo*2 * sizeof(*verts));
+		paliashdr->vertexes = (byte *)verts - (byte *)paliashdr;
+		for (i=0 ; i<paliashdr->numposes ; i++)
+			for (j=0 ; j<paliashdr->numverts_vbo ; j++)
+			{
+				verts[i*paliashdr->numverts_vbo*2 + j] = poseverts_mdl[i][desc[j].vertindex];
+				verts[i*paliashdr->numverts_vbo*2 + j + paliashdr->numverts_vbo] = poseverts_mdl[i][desc[j].vertindex + paliashdr->numverts_vbo];
+			}
+		break;
+	case PV_QUAKE1:
 		verts = (trivertx_t *) Hunk_Alloc (paliashdr->numposes * paliashdr->numverts_vbo * sizeof(*verts));
 		paliashdr->vertexes = (byte *)verts - (byte *)paliashdr;
 		for (i=0 ; i<paliashdr->numposes ; i++)
 			for (j=0 ; j<paliashdr->numverts_vbo ; j++)
 				verts[i*paliashdr->numverts_vbo + j] = poseverts_mdl[i][desc[j].vertindex];
+		break;
+	case PV_QUAKE3:
+		break;	//invalid here.
+	}
 }
 
 #define NUMVERTEXNORMALS	 162
@@ -147,10 +164,18 @@ void GLMesh_LoadVertexBuffer (qmodel_t *m, aliashdr_t *mainhdr)
 	//count how much space we're going to need.
 	for(hdr = mainhdr, numverts = 0, numindexes = 0; ; )
 	{
-		if (hdr->posevertssize == 1)
+		switch(hdr->poseverttype)
+		{
+		case PV_QUAKE1:
 			totalvbosize += (hdr->numposes * hdr->numverts_vbo * sizeof (meshxyz_mdl_t)); // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
-		else if (hdr->posevertssize == 2)
+			break;
-			totalvbosize += (hdr->numposes * hdr->numverts_vbo * sizeof (meshxyz_md3_t)); // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
+		case PV_QUAKEFORGE:
+			totalvbosize += (hdr->numposes * hdr->numverts_vbo * sizeof (meshxyz_mdl16_t));
+			break;
+		case PV_QUAKE3:
+			totalvbosize += (hdr->numposes * hdr->numverts_vbo * sizeof (meshxyz_md3_t));
+			break;
+		}
 
 		numverts += hdr->numverts_vbo;
 		numindexes += hdr->numindexes;
@@ -200,8 +225,9 @@ void GLMesh_LoadVertexBuffer (qmodel_t *m, aliashdr_t *mainhdr)
 		hdr->vbovertofs = vertofs;
 
 	// fill in the vertices at the start of the buffer
-		if (hdr->posevertssize == 1)
+		switch(hdr->poseverttype)
 		{
+		case PV_QUAKE1:
 			for (f = 0; f < hdr->numposes; f++) // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
 			{
 				int v;
@@ -225,9 +251,33 @@ void GLMesh_LoadVertexBuffer (qmodel_t *m, aliashdr_t *mainhdr)
 					xyz[v].normal[3] = 0;	// unused; for 4-byte alignment
 				}
 			}
-		}
+			break;
-		else if (hdr->posevertssize == 2)
+		case PV_QUAKEFORGE:
+			for (f = 0; f < hdr->numposes; f++) // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
 			{
+				int v;
+				meshxyz_mdl16_t *xyz = (meshxyz_mdl16_t *) (vbodata + vertofs);
+				const trivertx_t *tv = (trivertx_t*)trivertexes + (hdr->numverts_vbo*2 * f);
+				vertofs += hdr->numverts_vbo * sizeof (*xyz);
+
+				for (v = 0; v < hdr->numverts_vbo; v++, tv++)
+				{
+					xyz[v].xyz[0] = (tv->v[0]<<8) | tv[hdr->numverts_vbo].v[0];
+					xyz[v].xyz[1] = (tv->v[1]<<8) | tv[hdr->numverts_vbo].v[0];
+					xyz[v].xyz[2] = (tv->v[2]<<8) | tv[hdr->numverts_vbo].v[0];
+					xyz[v].xyz[3] = 1;	// need w 1 for 4 byte vertex compression
+
+					// map the normal coordinates in [-1..1] to [-127..127] and store in an unsigned char.
+					// this introduces some error (less than 0.004), but the normals were very coarse
+					// to begin with
+					xyz[v].normal[0] = 127 * r_avertexnormals[tv->lightnormalindex][0];
+					xyz[v].normal[1] = 127 * r_avertexnormals[tv->lightnormalindex][1];
+					xyz[v].normal[2] = 127 * r_avertexnormals[tv->lightnormalindex][2];
+					xyz[v].normal[3] = 0;	// unused; for 4-byte alignment
+				}
+			}
+			break;
+		case PV_QUAKE3:
 			for (f = 0; f < hdr->numposes; f++) // ericw -- what RMQEngine called nummeshframes is called numposes in QuakeSpasm
 			{
 				int v;
@@ -254,6 +304,7 @@ void GLMesh_LoadVertexBuffer (qmodel_t *m, aliashdr_t *mainhdr)
 					xyz[v].normal[3] = 0;	// unused; for 4-byte alignment
 				}
 			}
+			break;
 		}
 
 		// fill in the ST coords at the end of the buffer
@@ -269,21 +320,23 @@ void GLMesh_LoadVertexBuffer (qmodel_t *m, aliashdr_t *mainhdr)
 			hdr->vbostofs = stofs; 
 			st = (meshst_t *) (vbodata + stofs);
 			stofs += hdr->numverts_vbo*sizeof(*st);
-			if (hdr->posevertssize == 2)
+			switch(hdr->poseverttype)
 			{
+			case PV_QUAKE3:
 				for (f = 0; f < hdr->numverts_vbo; f++)
 				{	//md3 has floating-point skin coords. use the values directly.
 					st[f].st[0] = hscale * desc[f].st[0];
 					st[f].st[1] = vscale * desc[f].st[1];
 				}
-			}
+				break;
-			else
+			case PV_QUAKEFORGE:
-			{
+			case PV_QUAKE1:
 				for (f = 0; f < hdr->numverts_vbo; f++)
 				{
 					st[f].st[0] = hscale * ((float) desc[f].st[0] + 0.5f) / (float) hdr->skinwidth;
 					st[f].st[1] = vscale * ((float) desc[f].st[1] + 0.5f) / (float) hdr->skinheight;
 				}
+				break;
 			}
 		}
 
@@ -528,7 +581,7 @@ void Mod_LoadMD3Model (qmodel_t *mod, void *buffer)
 		else
 			osurf->nextsurface = 0;
 		
-		osurf->posevertssize = 2;
+		osurf->poseverttype = PV_QUAKE3;
 		osurf->numverts_vbo = osurf->numverts = LittleLong(pinsurface->numVerts);
 		pinvert = (md3XyzNormal_t*)((byte*)pinsurface + LittleLong(pinsurface->ofsXyzNormals));
 		poutvert = (md3XyzNormal_t *) Hunk_Alloc (numframes * osurf->numverts * sizeof(*poutvert));

Quake/gl_model.c

@@ -31,7 +31,7 @@ char	loadname[32];	// for hunk tags
 
 void Mod_LoadSpriteModel (qmodel_t *mod, void *buffer);
 void Mod_LoadBrushModel (qmodel_t *mod, void *buffer);
-void Mod_LoadAliasModel (qmodel_t *mod, void *buffer);
+void Mod_LoadAliasModel (qmodel_t *mod, void *buffer, int pvtype);
 void Mod_LoadMD3Model (qmodel_t *mod, void *buffer);
 qmodel_t *Mod_LoadModel (qmodel_t *mod, qboolean crash);
 
@@ -373,7 +373,10 @@ qmodel_t *Mod_LoadModel (qmodel_t *mod, qboolean crash)
 	switch (mod_type)
 	{
 	case IDPOLYHEADER:
-		Mod_LoadAliasModel (mod, buf);
+		Mod_LoadAliasModel (mod, buf, PV_QUAKE1);
+		break;
+	case (('M'<<0)+('D'<<8)+('1'<<16)+('6'<<24)):	//QF 16bit variation
+		Mod_LoadAliasModel (mod, buf, PV_QUAKEFORGE);
 		break;
 
 	case IDSPRITEHEADER:
@@ -1446,8 +1449,8 @@ void Mod_LoadFaces (lump_t *l, qboolean bsp2)
 		if (Mod_ParseWorldspawnKey(loadmodel, "lightmap_scale", scalebuf, sizeof(scalebuf)))
 		{
 			i = atoi(scalebuf);
-			for (defaultshift = 0; (1<<defaultshift) < i && defaultshift < 254; defaultshift++)
+			for(defaultshift = 0; i > 1; defaultshift++)
-				break;
+				i >>= 1;
 		}
 	}
 
@@ -2583,7 +2586,7 @@ byte		*player_8bit_texels;
 Mod_LoadAliasFrame
 =================
 */
-void * Mod_LoadAliasFrame (void * pin, maliasframedesc_t *frame)
+static void * Mod_LoadAliasFrame (void * pin, maliasframedesc_t *frame, int pvtype)
 {
 	trivertx_t		*pinframe;
 	int				i;
@@ -2612,7 +2615,7 @@ void * Mod_LoadAliasFrame (void * pin, maliasframedesc_t *frame)
 	poseverts_mdl[posenum] = pinframe;
 	posenum++;
 
-	pinframe += pheader->numverts;
+	pinframe += pheader->numverts*(pvtype==PV_QUAKEFORGE?2:1);
 
 	return (void *)pinframe;
 }
@@ -2623,7 +2626,7 @@ void * Mod_LoadAliasFrame (void * pin, maliasframedesc_t *frame)
 Mod_LoadAliasGroup
 =================
 */
-void *Mod_LoadAliasGroup (void * pin,  maliasframedesc_t *frame)
+static void *Mod_LoadAliasGroup (void * pin,  maliasframedesc_t *frame, int pvtype)
 {
 	daliasgroup_t		*pingroup;
 	int					i, numframes;
@@ -2660,7 +2663,7 @@ void *Mod_LoadAliasGroup (void * pin,  maliasframedesc_t *frame)
 		poseverts_mdl[posenum] = (trivertx_t *)((daliasframe_t *)ptemp + 1);
 		posenum++;
 
-		ptemp = (trivertx_t *)((daliasframe_t *)ptemp + 1) + pheader->numverts;
+		ptemp = (trivertx_t *)((daliasframe_t *)ptemp + 1) + pheader->numverts*(pvtype==PV_QUAKEFORGE?2:1);
 	}
 
 	return ptemp;
@@ -2878,8 +2881,9 @@ void Mod_CalcAliasBounds (aliashdr_t *a)
 	{
 		if (a->numposes && a->numverts)
 		{
-			if (a->posevertssize == 1)
+			switch(a->poseverttype)
 			{
+			case PV_QUAKE1:
 				//process verts
 				for (i=0 ; i<a->numposes; i++)
 					for (j=0; j<a->numverts; j++)
@@ -2899,9 +2903,29 @@ void Mod_CalcAliasBounds (aliashdr_t *a)
 						if (radius < dist)
 							radius = dist;
 					}
-			}
+				break;
-			else if (a->posevertssize == 2)
+			case PV_QUAKEFORGE:
+				//process verts
+				for (i=0 ; i<a->numposes; i++)
+					for (j=0; j<a->numverts; j++)
 					{
+						for (k=0; k<3;k++)
+							v[k] = (poseverts_mdl[i][j].v[k] * pheader->scale[k]) + (poseverts_mdl[i][j+a->numverts].v[k] * pheader->scale[k]/256.f) + (pheader->scale_origin[k]);
+
+						for (k=0; k<3;k++)
+						{
+							loadmodel->mins[k] = q_min(loadmodel->mins[k], v[k]);
+							loadmodel->maxs[k] = q_max(loadmodel->maxs[k], v[k]);
+						}
+						dist = v[0] * v[0] + v[1] * v[1];
+						if (yawradius < dist)
+							yawradius = dist;
+						dist += v[2] * v[2];
+						if (radius < dist)
+							radius = dist;
+					}
+				break;
+			case PV_QUAKE3:
 				//process verts
 				for (i=0 ; i<a->numposes; i++)
 				{
@@ -2924,6 +2948,7 @@ void Mod_CalcAliasBounds (aliashdr_t *a)
 							radius = dist;
 					}
 				}
+				break;
 			}
 		}
 
@@ -3028,7 +3053,7 @@ void Mod_SetExtraFlags (qmodel_t *mod)
 Mod_LoadAliasModel
 =================
 */
-void Mod_LoadAliasModel (qmodel_t *mod, void *buffer)
+void Mod_LoadAliasModel (qmodel_t *mod, void *buffer, int pvtype)
 {
 	int					i, j;
 	mdl_t				*pinmodel;
@@ -3175,13 +3200,13 @@ void Mod_LoadAliasModel (qmodel_t *mod, void *buffer)
 		aliasframetype_t	frametype;
 		frametype = (aliasframetype_t) LittleLong (pframetype->type);
 		if (frametype == ALIAS_SINGLE)
-			pframetype = (daliasframetype_t *) Mod_LoadAliasFrame (pframetype + 1, &pheader->frames[i]);
+			pframetype = (daliasframetype_t *) Mod_LoadAliasFrame (pframetype + 1, &pheader->frames[i], pvtype);
 		else
-			pframetype = (daliasframetype_t *) Mod_LoadAliasGroup (pframetype + 1, &pheader->frames[i]);
+			pframetype = (daliasframetype_t *) Mod_LoadAliasGroup (pframetype + 1, &pheader->frames[i], pvtype);
 	}
 
 	pheader->numposes = posenum;
-	pheader->posevertssize = 1;
+	pheader->poseverttype = pvtype;	//it would be safe to always store PV_QUAKE1 here if you wanted to drop the low-order data.
 
 	mod->type = mod_alias;
 

Quake/gl_model.h

@@ -293,6 +293,12 @@ typedef struct meshxyz_mdl_s
 	signed char normal[4];
 } meshxyz_mdl_t;
 
+typedef struct meshxyz_mdl16_s
+{
+	unsigned short xyz[4];
+	signed char normal[4];
+} meshxyz_mdl16_t;
+
 typedef struct meshxyz_md3_s
 {
 	signed short xyz[4];
@@ -369,7 +375,12 @@ typedef struct {
 
 	intptr_t					nextsurface;	//spike
 	int					numposes;
-	int					posevertssize;	//spike 1=mdl, 2=md3
+	enum
+	{
+		PV_QUAKE1 = 1,	//trivertx_t
+		PV_QUAKE3 = 2,	//md3XyzNormal_t
+		PV_QUAKEFORGE,	//trivertx16_t
+	} poseverttype;	//spike
 	struct gltexture_s	*gltextures[MAX_SKINS][4]; //johnfitz
 	struct gltexture_s	*fbtextures[MAX_SKINS][4]; //johnfitz
 	intptr_t					texels[MAX_SKINS];	// only for player skins

Quake/r_alias.c

@@ -99,6 +99,11 @@ static void *GLARB_GetXYZOffset_MDL (aliashdr_t *hdr, int pose)
 	const size_t xyzoffs = offsetof (meshxyz_mdl_t, xyz);
 	return currententity->model->meshvboptr+(hdr->vbovertofs + (hdr->numverts_vbo * pose * sizeof (meshxyz_mdl_t)) + xyzoffs);
 }
+static void *GLARB_GetXYZOffset_MDLQF (aliashdr_t *hdr, int pose)
+{
+	const size_t xyzoffs = offsetof (meshxyz_mdl16_t, xyz);
+	return currententity->model->meshvboptr+(hdr->vbovertofs + (hdr->numverts_vbo * pose * sizeof (meshxyz_mdl16_t)) + xyzoffs);
+}
 static void *GLARB_GetXYZOffset_MD3 (aliashdr_t *hdr, int pose)
 {
 	const size_t xyzoffs = offsetof (meshxyz_md3_t, xyz);
@@ -118,6 +123,11 @@ static void *GLARB_GetNormalOffset_MDL (aliashdr_t *hdr, int pose)
 	const size_t normaloffs = offsetof (meshxyz_mdl_t, normal);
 	return currententity->model->meshvboptr+(hdr->vbovertofs + (hdr->numverts_vbo * pose * sizeof (meshxyz_mdl_t)) + normaloffs);
 }
+static void *GLARB_GetNormalOffset_MDLQF (aliashdr_t *hdr, int pose)
+{
+	const size_t normaloffs = offsetof (meshxyz_mdl16_t, normal);
+	return currententity->model->meshvboptr+(hdr->vbovertofs + (hdr->numverts_vbo * pose * sizeof (meshxyz_mdl16_t)) + normaloffs);
+}
 static void *GLARB_GetNormalOffset_MD3 (aliashdr_t *hdr, int pose)
 {
 	const size_t normaloffs = offsetof (meshxyz_md3_t, normal);
@@ -260,21 +270,29 @@ void GL_DrawAliasFrame_GLSL (aliashdr_t *paliashdr, lerpdata_t lerpdata, gltextu
 	GL_EnableVertexAttribArrayFunc (pose2NormalAttrIndex);
 
 	GL_VertexAttribPointerFunc (texCoordsAttrIndex, 2, GL_FLOAT, GL_FALSE, 0, currententity->model->meshvboptr+paliashdr->vbostofs);
-	if (paliashdr->posevertssize == 1)
+	switch(paliashdr->poseverttype)
 	{
+	case PV_QUAKE1:
 		GL_VertexAttribPointerFunc (pose1VertexAttrIndex, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof (meshxyz_mdl_t), GLARB_GetXYZOffset_MDL (paliashdr, lerpdata.pose1));
 		GL_VertexAttribPointerFunc (pose2VertexAttrIndex, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof (meshxyz_mdl_t), GLARB_GetXYZOffset_MDL (paliashdr, lerpdata.pose2));
 		// GL_TRUE to normalize the signed bytes to [-1 .. 1]
 		GL_VertexAttribPointerFunc (pose1NormalAttrIndex, 4, GL_BYTE, GL_TRUE, sizeof (meshxyz_mdl_t), GLARB_GetNormalOffset_MDL (paliashdr, lerpdata.pose1));
 		GL_VertexAttribPointerFunc (pose2NormalAttrIndex, 4, GL_BYTE, GL_TRUE, sizeof (meshxyz_mdl_t), GLARB_GetNormalOffset_MDL (paliashdr, lerpdata.pose2));
-	}
+		break;
-	else if (paliashdr->posevertssize == 2)
+	case PV_QUAKEFORGE:
-	{
+		GL_VertexAttribPointerFunc (pose1VertexAttrIndex, 4, GL_UNSIGNED_SHORT, GL_FALSE, sizeof (meshxyz_mdl16_t), GLARB_GetXYZOffset_MDLQF (paliashdr, lerpdata.pose1));
+		GL_VertexAttribPointerFunc (pose2VertexAttrIndex, 4, GL_UNSIGNED_SHORT, GL_FALSE, sizeof (meshxyz_mdl16_t), GLARB_GetXYZOffset_MDLQF (paliashdr, lerpdata.pose2));
+		// GL_TRUE to normalize the signed bytes to [-1 .. 1]
+		GL_VertexAttribPointerFunc (pose1NormalAttrIndex, 4, GL_BYTE, GL_TRUE, sizeof (meshxyz_mdl16_t), GLARB_GetNormalOffset_MDLQF (paliashdr, lerpdata.pose1));
+		GL_VertexAttribPointerFunc (pose2NormalAttrIndex, 4, GL_BYTE, GL_TRUE, sizeof (meshxyz_mdl16_t), GLARB_GetNormalOffset_MDLQF (paliashdr, lerpdata.pose2));
+		break;
+	case PV_QUAKE3:
 		GL_VertexAttribPointerFunc (pose1VertexAttrIndex, 4, GL_SHORT, GL_FALSE, sizeof (meshxyz_md3_t), GLARB_GetXYZOffset_MD3 (paliashdr, lerpdata.pose1));
 		GL_VertexAttribPointerFunc (pose2VertexAttrIndex, 4, GL_SHORT, GL_FALSE, sizeof (meshxyz_md3_t), GLARB_GetXYZOffset_MD3 (paliashdr, lerpdata.pose2));
 		// GL_TRUE to normalize the signed bytes to [-1 .. 1]
 		GL_VertexAttribPointerFunc (pose1NormalAttrIndex, 4, GL_BYTE, GL_TRUE, sizeof (meshxyz_md3_t), GLARB_GetNormalOffset_MD3 (paliashdr, lerpdata.pose1));
 		GL_VertexAttribPointerFunc (pose2NormalAttrIndex, 4, GL_BYTE, GL_TRUE, sizeof (meshxyz_md3_t), GLARB_GetNormalOffset_MD3 (paliashdr, lerpdata.pose2));
+		break;
 	}
 
 // set uniforms
@@ -347,10 +365,13 @@ void GL_DrawAliasFrame (aliashdr_t *paliashdr, lerpdata_t lerpdata)
 	}
 
 	glEnableClientState(GL_VERTEX_ARRAY);
-	if (paliashdr->posevertssize == 1)
+	switch(paliashdr->poseverttype)
 	{
-		trivertx_t *verts1 = (trivertx_t*)((byte *)paliashdr + paliashdr->vertexes) + lerpdata.pose1 * paliashdr->numverts_vbo;
+	case PV_QUAKE1:
-		trivertx_t *verts2 = (trivertx_t*)((byte *)paliashdr + paliashdr->vertexes) + lerpdata.pose2 * paliashdr->numverts_vbo;
+	case PV_QUAKEFORGE:	//just going to ignore the extra data here.
+		{
+			trivertx_t *verts1 = (trivertx_t*)((byte *)paliashdr + paliashdr->vertexes) + lerpdata.pose1 * paliashdr->numverts_vbo*(paliashdr->poseverttype==PV_QUAKEFORGE?2:1);
+			trivertx_t *verts2 = (trivertx_t*)((byte *)paliashdr + paliashdr->vertexes) + lerpdata.pose2 * paliashdr->numverts_vbo*(paliashdr->poseverttype==PV_QUAKEFORGE?2:1);
 
 			if (iblend)
 			{
@@ -403,7 +424,8 @@ void GL_DrawAliasFrame (aliashdr_t *paliashdr, lerpdata_t lerpdata)
 				glVertexPointer(3, GL_FLOAT, sizeof (vpos[0]), vpos);
 			}
 		}
-	else if (paliashdr->posevertssize == 2)
+		break;
+	case PV_QUAKE3:
 		{
 			md3XyzNormal_t *verts1 = (md3XyzNormal_t*)((byte *)paliashdr + paliashdr->vertexes) + lerpdata.pose1 * paliashdr->numverts_vbo;
 			md3XyzNormal_t *verts2 = (md3XyzNormal_t*)((byte *)paliashdr + paliashdr->vertexes) + lerpdata.pose2 * paliashdr->numverts_vbo;
@@ -488,6 +510,8 @@ void GL_DrawAliasFrame (aliashdr_t *paliashdr, lerpdata_t lerpdata)
 				glVertexPointer(3, GL_SHORT, sizeof (meshxyz_md3_t), GLARB_GetXYZOffset_MD3 (paliashdr, lerpdata.pose2));
 			}
 		}
+		break;
+	}
 
 // set textures
 	GL_BindBuffer (GL_ARRAY_BUFFER, currententity->model->meshvbo);