fteqw/plugins/cod/codmod.c

#include "../plugin.h"
#include "../engine/common/com_mesh.h"
static plugfsfuncs_t *filefuncs;
static plugmodfuncs_t *modfuncs;

//Utility functions. silly plugins.
float Length(const vec3_t v) {return sqrt(DotProduct(v,v));}
float RadiusFromBounds (const vec3_t mins, const vec3_t maxs)
{
	int		i;
	vec3_t	corner;
	for (i=0 ; i<3 ; i++)
		corner[i] = fabs(mins[i]) > fabs(maxs[i]) ? fabs(mins[i]) : fabs(maxs[i]);
	return Length(corner);
}



struct fstream_s
{
	void *start;
	size_t len;
	size_t ofs;

	size_t numbones;
	galiasbone_t *bones;
	float *basepose;
};
struct lod_s
{
	float coverage;
	const char *name;
	unsigned short numtex;
	const char *tex[64];
};

static qboolean ReadEOF(struct fstream_s *f)
{
	return (f->ofs >= f->len);
}
static qbyte ReadByte(struct fstream_s *f)
{
	if (f->ofs+1 > f->len)
	{
		f->ofs++;
		return 0;
	}
	return ((qbyte*)f->start)[f->ofs++];
}
static const char *ReadBytes(struct fstream_s *f, size_t len)
{
	f->ofs+=len;
	if (f->ofs > f->len)
		return NULL;
	return &((const char*)f->start)[f->ofs-len];
}
static const char *ReadString(struct fstream_s *f)
{
	size_t len;
	for (len = 0; f->ofs+len < f->len && ((qbyte*)f->start)[f->ofs+len]; len++)
		;
	len++; //for the null
	f->ofs += len;
	return &((const qbyte*)f->start)[f->ofs-len];
}
static unsigned short ReadUInt16(struct fstream_s *f)
{
	unsigned short r;
	r = ReadByte(f);
	r|= ReadByte(f) << 8;
	return r;
}
static short ReadSInt16(struct fstream_s *f)
{
	return (signed short)ReadUInt16(f);
}
static unsigned int ReadUInt32(struct fstream_s *f)
{
	unsigned int r;
	r = ReadByte(f);
	r|= ReadByte(f) << 8;
	r|= ReadByte(f) << 16;
	r|= ReadByte(f) << 24;
	return r;
}
static float ReadFloat(struct fstream_s *f)
{
	union {
		unsigned int u;
		float f;
	} r;
	r.u = ReadByte(f);
	r.u|= ReadByte(f) << 8;
	r.u|= ReadByte(f) << 16;
	r.u|= ReadByte(f) << 24;
	return r.f;
}
static qboolean Mod_XModel_LoadPart (struct model_s *mod, struct fstream_s *f)
{
	unsigned short ver = ReadUInt16(f);
	unsigned short b, nboner = ReadUInt16(f);
	unsigned short nbonea = ReadUInt16(f);
	float rel[12];
	switch(ver)
	{
	case 0x0e:
		break;
	case 0x14:
		break;
	default:
		Con_Printf(CON_ERROR"%s: Unknown version %#x\n", mod->name, ver);
		return false;
	}
//	Con_Printf("%s: version %x rb:%i ab:%i\n", mod->name, ver, nboner, nbonea);
	f->numbones = nbonea+nboner;
	f->basepose = plugfuncs->GMalloc(&mod->memgroup, sizeof(*f->basepose)*12 * f->numbones);
	f->bones = plugfuncs->GMalloc(&mod->memgroup, sizeof(*f->bones) * f->numbones);

	for (b = 0; b < nbonea; b++)
	{	//root bones, with identity position. for some reason.
		f->bones[b].parent = -1;

		VectorClear(f->bones[b].ref.org);
		Vector4Set(f->bones[b].ref.quat, 0, 0, 0, 1);
		VectorSet(f->bones[b].ref.scale, 1, 1, 1);
		modfuncs->GenMatrixPosQuat4Scale(f->bones[b].ref.org, f->bones[b].ref.quat, f->bones[b].ref.scale, f->basepose + b*12);
	}
	for (; b < f->numbones; b++)
	{
		f->bones[b].parent = ReadByte(f);

		if (f->bones[b].parent >= b)
			Con_Printf(CON_ERROR"b%i (%s) has parent %i\n", b, f->bones[b].name, f->bones[b].parent);

		f->bones[b].ref.org[0] = ReadFloat(f);
		f->bones[b].ref.org[1] = ReadFloat(f);
		f->bones[b].ref.org[2] = ReadFloat(f);

		f->bones[b].ref.quat[0] = ReadSInt16(f)/32767.0f;
		f->bones[b].ref.quat[1] = ReadSInt16(f)/32767.0f;
		f->bones[b].ref.quat[2] = ReadSInt16(f)/32767.0f;
		f->bones[b].ref.quat[3] = 1.0-DotProduct(f->bones[b].ref.quat,f->bones[b].ref.quat);	//reconstruct the w part.
		if (f->bones[b].ref.quat[3]>0)
			f->bones[b].ref.quat[3] = sqrt(f->bones[b].ref.quat[3]);
		else
			f->bones[b].ref.quat[3] = 0;

		VectorSet(f->bones[b].ref.scale, 1, 1, 1);

		modfuncs->GenMatrixPosQuat4Scale(f->bones[b].ref.org, f->bones[b].ref.quat, f->bones[b].ref.scale, rel);
		modfuncs->ConcatTransforms((void*)(f->basepose + f->bones[b].parent*12), (void*)rel, (void*)(f->basepose + b*12));

//		Con_Printf("b%i: p:%i, [%f %f %f] [%f %f %f %f]\n", b, f->bones[b].parent, pos[0],pos[1],pos[2], quat[0],quat[1],quat[2],quat[3]);
	}
	for (b = 0; b < f->numbones; b++)
	{
		vec3_t mins, maxs;
		const char *n = ReadString(f);
		if (ver >= 0x14)
		{	//omitted.
			VectorClear(mins);
			VectorClear(maxs);
		}
		else
		{
			mins[0] = ReadFloat(f);
			mins[1] = ReadFloat(f);
			mins[2] = ReadFloat(f);
			maxs[0] = ReadFloat(f);
			maxs[1] = ReadFloat(f);
			maxs[2] = ReadFloat(f);
		}

		//hack... I assume the (game)code does a skel_setbone so this doesn't actually matter?
		if (!strcmp(n, "torso_stabilizer"))
			Vector4Set(f->bones[b].ref.quat, 0,0,0,1);

		Q_strlcpy(f->bones[b].name, n, sizeof(f->bones[b].name));
		modfuncs->M3x4_Invert(f->basepose+12*b, f->bones[b].inverse);

//		if (ver >= 0x14)
//			Con_Printf("b%i: %-20s\n", b, n);
//		else
//			Con_Printf("b%i: %-20s [%f %f %f] [%f %f %f]\n", b, n, mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
	}
	for (b = 0; b < f->numbones; b++)
		f->bones[b].group = ReadByte(f);	//presumed.
	return true;
}
static qboolean Mod_XModel_LoadSurfs (struct model_s *mod, struct fstream_s *f, struct lod_s *lod, float mincov)
{
	galiasinfo_t *surf;
	galiasskin_t *skins;
	skinframe_t *skinframe;
	unsigned short ver = ReadUInt16(f);
	unsigned short n, nsurfs = ReadUInt16(f);
	switch(ver)
	{
	case 0x0e:
		break;
	case 0x14:
		break;
	default:
		Con_Printf("%s: Unknown version %#x\n", mod->name, ver);
		return false;
	}

	if (!nsurfs)
		return true;	//nothing to do...

	surf = plugfuncs->GMalloc(&mod->memgroup,	sizeof(*surf)*nsurfs +
												sizeof(*skins)*nsurfs +
												sizeof(*skinframe)*nsurfs);
	skins = (galiasskin_t*)(surf+nsurfs);
	skinframe = (skinframe_t*)(skins+nsurfs);
	for (n = 0; n < nsurfs; n++)
	{
		surf[n].numbones = f->numbones;
		surf[n].ofsbones = f->bones;
		surf[n].baseframeofs = f->basepose;

		surf[n].mindist = mincov;
		surf[n].maxdist = lod->coverage;
		surf[n].shares_verts = n;
		surf[n].shares_bones = 0;
		surf[n].nextsurf = &surf[n+1];
		surf[n].ofsskins = &skins[n];
		surf[n].numskins = 1;
		skins[n].skinspeed = 0.1;
		skins[n].frame = &skinframe[n];
		skins[n].numframes = 1;
		Q_snprintf(surf[n].surfacename, sizeof(surf[n].surfacename), "%s/%i", lod->name, n);
		Q_strlcpy(skins[n].name, lod->name, sizeof(skins[n].name));
		if (n < lod->numtex)
			Q_snprintf(skinframe[n].shadername, sizeof(skinframe[n].shadername), (ver==0x0e)?"skins/%s":"%s", lod->tex[n]);
	}
	surf[nsurfs-1].nextsurf = mod->meshinfo;
	mod->meshinfo = surf;
	for(surf = surf[nsurfs-1].nextsurf; surf; surf = surf->nextsurf)
		surf->shares_verts += nsurfs;
	surf = mod->meshinfo;

	for (n = 0; n < nsurfs; n++, surf++)
	{
		int flags = ReadByte(f);
		int v, nverts = ReadUInt16(f);
		int t, ntris = ReadUInt16(f);
		int r, runs = (ver==0xe)?ReadUInt16(f):0;
		unsigned short wcount = 0;
		qbyte run;
		unsigned int idx1, idx2, idx3;

		unsigned short boneidx = ReadUInt16(f);
		qboolean boney = boneidx == (unsigned short)~0u;
		int exweights = 0;
		unsigned short *vw = NULL;
//		unsigned short bunk2;

		vec3_t norm;
		vec4_t xyzw;
		const float *matrix;

		(void)flags;

		if (boney)
		{
			if (ver == 0x0e)
				exweights = ReadUInt16(f);
			/*bunk2 =*/ ReadUInt16(f); //seems to be vaguely related to vert/triangle counts.
		}

		surf->numverts = nverts;

		if (ver == 0xe)
		{	//cod1
			surf->ofs_indexes		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_indexes		) * ntris*3);
			for(t = 0, r = 0; r < runs; r++)
			{
				run = ReadByte(f);
				idx1 = ReadUInt16(f);
				idx2 = ReadUInt16(f);
				run-=2;

				for (;;)
				{	//strip
					if(!run--) break;
					idx3 = ReadUInt16(f);
					if (idx1 != idx2 && idx1 != idx3 && idx2 != idx3 && t < ntris)
					{
						surf->ofs_indexes[t*3+0] = idx1;
						surf->ofs_indexes[t*3+1] = idx2;
						surf->ofs_indexes[t*3+2] = idx3;
						t++;
					}
					idx1 = idx2;
					idx2 = idx3;

					//alternating triangles flip the order
					if(!run--) break;
					idx3 = ReadUInt16(f);
					if (idx1 != idx2 && idx1 != idx3 && idx2 != idx3 && t < ntris)
					{
						surf->ofs_indexes[t*3+2] = idx1;
						surf->ofs_indexes[t*3+1] = idx2;
						surf->ofs_indexes[t*3+0] = idx3;
						t++;
					}
					idx1 = idx2;
					idx2 = idx3;
				}
			}

			if (ntris != t)
			{
				Con_Printf(CON_ERROR"Expected %i tris, got %i from %i runs\n", ntris, t, r);
				return false;
			}
			surf->numindexes = t*3;

			//lazy and a bit slower.
			surf->ofs_st_array		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_st_array		) * surf->numverts);
			surf->ofs_skel_xyz		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_xyz		) * surf->numverts);
			surf->ofs_skel_norm		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_norm	) * surf->numverts);
			if (boney || f->numbones>0)
			{
				surf->ofs_skel_idx		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_idx		) * surf->numverts);
				surf->ofs_skel_weight	= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_weight	) * surf->numverts);
				vw = memset(alloca(sizeof(*vw)*nverts), 0, sizeof(*vw)*nverts);
			}
			boneidx = min(boneidx,f->numbones-1);

			for (v = 0; v < nverts; v++)
			{
				norm[0]	= ReadFloat(f);
				norm[1]	= ReadFloat(f);
				norm[2]	= ReadFloat(f);
				surf->ofs_st_array[v][0]	= ReadFloat(f);
				surf->ofs_st_array[v][1]	= ReadFloat(f);
				if (boney)
				{
					wcount = ReadUInt16(f);
					boneidx = ReadUInt16(f);
					boneidx = min(boneidx,f->numbones-1);
				}

				xyzw[0]	= ReadFloat(f);
				xyzw[1]	= ReadFloat(f);
				xyzw[2]	= ReadFloat(f);
				if (wcount)
				{
					xyzw[3] = ReadFloat(f);
					VectorScale(xyzw, xyzw[3], xyzw);
				}
				else
					xyzw[3]	= 1;

				if (surf->ofs_skel_idx)
				{
					vw[v] = wcount;	//urgh.
					surf->ofs_skel_idx[v][0] = surf->ofs_skel_idx[v][1] = surf->ofs_skel_idx[v][2] = surf->ofs_skel_idx[v][3] = boneidx;	//set all of them, cache might thank us.
					surf->ofs_skel_weight[v][0] = xyzw[3];
				}

				//calculate the correct position in the base pose
				matrix = f->basepose + boneidx*12;
				surf->ofs_skel_xyz[ v][0] = xyzw[0] * matrix[0] + xyzw[1] * matrix[1] + xyzw[2] * matrix[ 2] + xyzw[3] * matrix[ 3];
				surf->ofs_skel_xyz[ v][1] = xyzw[0] * matrix[4] + xyzw[1] * matrix[5] + xyzw[2] * matrix[ 6] + xyzw[3] * matrix[ 7];
				surf->ofs_skel_xyz[ v][2] = xyzw[0] * matrix[8] + xyzw[1] * matrix[9] + xyzw[2] * matrix[10] + xyzw[3] * matrix[11];
				surf->ofs_skel_norm[v][0] = norm[0] * matrix[0] + norm[1] * matrix[1] + norm[2] * matrix[ 2];
				surf->ofs_skel_norm[v][1] = norm[0] * matrix[4] + norm[1] * matrix[5] + norm[2] * matrix[ 6];
				surf->ofs_skel_norm[v][2] = norm[0] * matrix[8] + norm[1] * matrix[9] + norm[2] * matrix[10];
			}
			if (vw)
			{
				float lowestv;
				int lowesti, j;
				for (v = 0; v < nverts; v++)
				{
					for (; vw[v] > 0; vw[v]--)
					{
						if (--exweights < 0)
							break;
						boneidx = ReadUInt16(f);
						boneidx = min(boneidx,f->numbones-1);
						xyzw[0]	= ReadFloat(f);
						xyzw[1]	= ReadFloat(f);
						xyzw[2]	= ReadFloat(f);
						xyzw[3] = ReadFloat(f);
						VectorScale(xyzw, xyzw[3], xyzw);

						matrix = f->basepose + boneidx*12;
						surf->ofs_skel_xyz[ v][0] += xyzw[0] * matrix[0] + xyzw[1] * matrix[1] + xyzw[2] * matrix[ 2] + xyzw[3] * matrix[ 3];
						surf->ofs_skel_xyz[ v][1] += xyzw[0] * matrix[4] + xyzw[1] * matrix[5] + xyzw[2] * matrix[ 6] + xyzw[3] * matrix[ 7];
						surf->ofs_skel_xyz[ v][2] += xyzw[0] * matrix[8] + xyzw[1] * matrix[9] + xyzw[2] * matrix[10] + xyzw[3] * matrix[11];

						lowesti = 0;
						lowestv = surf->ofs_skel_weight[v][0];
						for (j = 1; j < countof(surf->ofs_skel_idx[v]); j++)
						{
							if (surf->ofs_skel_weight[v][j] < lowestv)
								lowestv = surf->ofs_skel_weight[v][lowesti=j];
						}
						if (lowestv < xyzw[3])
						{
							surf->ofs_skel_idx[v][lowesti] = boneidx;
							surf->ofs_skel_weight[v][lowesti] = xyzw[3];
						}
					}
					//compensate for any missing weights
					xyzw[3] = surf->ofs_skel_weight[v][0]+surf->ofs_skel_weight[v][1]+surf->ofs_skel_weight[v][2]+surf->ofs_skel_weight[v][3];
					if (xyzw[3]>0)
						Vector4Scale(surf->ofs_skel_weight[v], 1/xyzw[3], surf->ofs_skel_weight[v]);
				}
			}
			if (exweights)
			{	//something was misread
				surf->numverts = 0;
				surf->numindexes = 0;
				return false;
			}

			//compute the tangents that are not stored in the file.
			surf->ofs_skel_svect	= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_svect	) * surf->numverts);
			surf->ofs_skel_tvect	= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_tvect	) * surf->numverts);
			modfuncs->AccumulateTextureVectors(surf->ofs_skel_xyz, surf->ofs_st_array, surf->ofs_skel_norm, surf->ofs_skel_svect, surf->ofs_skel_tvect, surf->ofs_indexes, surf->numindexes, false);
			modfuncs->NormaliseTextureVectors(surf->ofs_skel_norm, surf->ofs_skel_svect, surf->ofs_skel_tvect, surf->numverts, false);
		}
		else if (ver == 0x14)
		{	//cod2
			surf->ofs_st_array		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_st_array		) * surf->numverts);
			surf->ofs_skel_xyz		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_xyz		) * surf->numverts);
			surf->ofs_skel_norm		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_norm	) * surf->numverts);
			surf->ofs_skel_svect	= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_svect	) * surf->numverts);
			surf->ofs_skel_tvect	= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_tvect	) * surf->numverts);
			surf->ofs_rgbaub		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_rgbaub		) * surf->numverts);

			if (boney || f->numbones)
			{
				surf->ofs_skel_idx		= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_idx		) * surf->numverts);
				surf->ofs_skel_weight	= plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_skel_weight	) * surf->numverts);
			}
			boneidx = min(boneidx,f->numbones-1);

			for (v = 0; v < nverts; v++)
			{
				surf->ofs_skel_norm[v][0]	= ReadFloat(f);
				surf->ofs_skel_norm[v][1]	= ReadFloat(f);
				surf->ofs_skel_norm[v][2]	= ReadFloat(f);
				surf->ofs_rgbaub[v][0]		= ReadByte(f);
				surf->ofs_rgbaub[v][1]		= ReadByte(f);
				surf->ofs_rgbaub[v][2]		= ReadByte(f);
				surf->ofs_rgbaub[v][3]		= ReadByte(f);
				surf->ofs_st_array[v][0]	= ReadFloat(f);
				surf->ofs_st_array[v][1]	= ReadFloat(f);
				surf->ofs_skel_svect[v][0]	= ReadFloat(f);
				surf->ofs_skel_svect[v][1]	= ReadFloat(f);
				surf->ofs_skel_svect[v][2]	= ReadFloat(f);
				surf->ofs_skel_tvect[v][0]	= ReadFloat(f);
				surf->ofs_skel_tvect[v][1]	= ReadFloat(f);
				surf->ofs_skel_tvect[v][2]	= ReadFloat(f);
				if (boney)
				{
					int w;
					wcount = ReadByte(f);
					boneidx = ReadUInt16(f);
					boneidx = min(boneidx,f->numbones-1);
					xyzw[0]	= ReadFloat(f);
					xyzw[1]	= ReadFloat(f);
					xyzw[2]	= ReadFloat(f);
					xyzw[3] = wcount?ReadByte(f)/255.f:1;
					VectorScale(xyzw, xyzw[3], xyzw);
					matrix = f->basepose + boneidx*12;
					surf->ofs_skel_xyz[ v][0] = xyzw[0] * matrix[0] + xyzw[1] * matrix[1] + xyzw[2] * matrix[ 2] + xyzw[3] * matrix[ 3];
					surf->ofs_skel_xyz[ v][1] = xyzw[0] * matrix[4] + xyzw[1] * matrix[5] + xyzw[2] * matrix[ 6] + xyzw[3] * matrix[ 7];
					surf->ofs_skel_xyz[ v][2] = xyzw[0] * matrix[8] + xyzw[1] * matrix[9] + xyzw[2] * matrix[10] + xyzw[3] * matrix[11];

					surf->ofs_skel_idx[v][0] = surf->ofs_skel_idx[v][1] = surf->ofs_skel_idx[v][2] = surf->ofs_skel_idx[v][3] = boneidx;
					surf->ofs_skel_weight[v][0] = xyzw[3]; surf->ofs_skel_weight[v][1] = surf->ofs_skel_weight[v][2] = surf->ofs_skel_weight[v][3] = 0;

					for (w = 1; w <= wcount; w++)
					{
						boneidx = ReadUInt16(f);
						boneidx = min(boneidx,f->numbones-1);
						xyzw[0] = ReadFloat(f);
						xyzw[1] = ReadFloat(f);
						xyzw[2] = ReadFloat(f);
						xyzw[3] = ReadUInt16(f)/65535.f;
						VectorScale(xyzw, xyzw[3], xyzw);
						matrix = f->basepose + boneidx*12;
						surf->ofs_skel_xyz[ v][0] += xyzw[0] * matrix[0] + xyzw[1] * matrix[1] + xyzw[2] * matrix[ 2] + xyzw[3] * matrix[ 3];
						surf->ofs_skel_xyz[ v][1] += xyzw[0] * matrix[4] + xyzw[1] * matrix[5] + xyzw[2] * matrix[ 6] + xyzw[3] * matrix[ 7];
						surf->ofs_skel_xyz[ v][2] += xyzw[0] * matrix[8] + xyzw[1] * matrix[9] + xyzw[2] * matrix[10] + xyzw[3] * matrix[11];
						if (w < 4)
						{
							surf->ofs_skel_idx[v][w] = boneidx;
							surf->ofs_skel_weight[v][w] = xyzw[3];
						}
					}

					//compensate for any missing weights
					xyzw[3] = surf->ofs_skel_weight[v][0]+surf->ofs_skel_weight[v][1]+surf->ofs_skel_weight[v][2]+surf->ofs_skel_weight[v][3];
					if (xyzw[3]>0&&xyzw[3]!=1)
						Vector4Scale(surf->ofs_skel_weight[v], 1/xyzw[3], surf->ofs_skel_weight[v]);
				}
				else
				{
					surf->ofs_skel_xyz[v][0]	= ReadFloat(f);
					surf->ofs_skel_xyz[v][1]	= ReadFloat(f);
					surf->ofs_skel_xyz[v][2]	= ReadFloat(f);

					if (surf->ofs_skel_idx)
					{
						surf->ofs_skel_idx[v][0] = surf->ofs_skel_idx[v][1] = surf->ofs_skel_idx[v][2] = surf->ofs_skel_idx[v][3] = boneidx;
						surf->ofs_skel_weight[v][0] = 1; surf->ofs_skel_weight[v][1] = surf->ofs_skel_weight[v][2] = surf->ofs_skel_weight[v][3] = 0;
					}
				}
			}

			//indexes moved to AFTER. also triangles instead of weird strips. much nicer.
			surf->numindexes = ntris*3;
			surf->ofs_indexes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf->ofs_indexes		) * surf->numindexes);
			for (v = 0; v < ntris*3; v++)
				surf->ofs_indexes[v] = ReadUInt16(f);
		}
	}
	return true;
}

struct codbone_s
{	//source data is the number of samples, the pose index for each sample and THEN the actual samples at the specified sparse poses.
//	const char *name;
	unsigned int numquats;
	qboolean flip;
	struct
	{
		unsigned short ts;
		signed short v[3];
	} *quats;
	unsigned int numcoords;
	struct
	{
		unsigned int ts;
		vec3_t v;
	} *coord;
};

static void Mod_XAnim_LoadQuats (struct model_s *mod, struct fstream_s *f, struct codbone_s *b, unsigned int maxts, qboolean flipquat, qboolean zonly)
{
	unsigned int i, n = ReadUInt16(f);
	b->flip = flipquat;
	if (n)
	{
		b->numquats = n;
		b->quats = plugfuncs->GMalloc(&mod->memgroup, sizeof(*b->quats)*n);
		if (n == 1 || n == maxts)
			for (i = 0; i < n; i++)
				b->quats[i].ts = i;
		else if (maxts > 0xff)
			for (i = 0; i < n; i++)
				b->quats[i].ts = ReadUInt16(f);
		else
			for (i = 0; i < n; i++)
				b->quats[i].ts = ReadByte(f);

		for (i = 0; i < n; i++)
		{
			b->quats[i].v[0] = zonly?0:ReadSInt16(f);
			b->quats[i].v[1] = zonly?0:ReadSInt16(f);
			b->quats[i].v[2] =         ReadSInt16(f);
		}
	}
}
static void Mod_XAnim_LoadCoords (struct model_s *mod, struct fstream_s *f, struct codbone_s *b, unsigned int maxts)
{
	unsigned int i, n = ReadUInt16(f);
	if (n)
	{
		b->numcoords = n;
		b->coord = plugfuncs->GMalloc(&mod->memgroup, sizeof(*b->coord)*n);
		if (n == 1 || n == maxts)
			for (i = 0; i < n; i++)
				b->coord[i].ts = i;
		else if (maxts > 0xff)
			for (i = 0; i < n; i++)
				b->coord[i].ts = ReadUInt16(f);
		else
			for (i = 0; i < n; i++)
				b->coord[i].ts = ReadByte(f);

		for (i = 0; i < n; i++)
		{
			b->coord[i].v[0] = ReadFloat(f);
			b->coord[i].v[1] = ReadFloat(f);
			b->coord[i].v[2] = ReadFloat(f);
		}
	}
}
static float *QDECL Mod_XAnim_GetRawBones(const struct galiasinfo_s *animmesh, const struct galiasanimation_s *a, float time, float *bonematrixstorage, const struct galiasbone_s *boneinf, int numbones)
{
	const struct codbone_s *bone = (const void*)(a+1);
	size_t b, i, j;
	int ts;
	float frac;
	galiasrefpose_t ref;
	time *= a->rate;
	ts = time;
	frac = time - ts;	//FIXME: negative time!
	if (a->loop)
	{
		ts %= a->numposes;
		if (ts < 0)
			ts += a->numposes;
	}
	ts = bound(0, ts, a->numposes);
	if (!boneinf)
	{	//our own bones?!? that'll be a horrible mess, but if you're really asking for that...
		boneinf = animmesh->ofsbones;
		numbones = min(numbones,animmesh->numbones);
	}

	for (b = 0; b < numbones; b++, boneinf++)
	{
		ref = boneinf->ref;
		for (j = 0; j < animmesh->numbones; j++)
		{
			if (!strcmp(boneinf->name, animmesh->ofsbones[j].name))
			{	//okay this is the one we want. replace the reference pose with the animated data.
				bone = (const struct codbone_s*)(a+1) + j;
				for (i = 0; i < bone->numquats; i++)
					if (ts < bone->quats[i].ts)
						break;	//we flew too close to the sun!
				if (!i--)
					;	//use the value from the model.
				else if (i < bone->numquats-1 && bone->quats[i+1].ts == ts+1)
				{
					vec4_t oq,nq;
					VectorScale(bone->quats[i].v, 1.f/32767, oq);
					oq[3] = 1 - DotProduct(oq,oq);
					if (oq[3] > 0)
						oq[3] = sqrt(oq[3]);

					VectorScale(bone->quats[i+1].v, 1.f/32767, nq);
					nq[3] = 1 - DotProduct(nq,nq);
					if (nq[3] > 0)
						nq[3] = sqrt(nq[3]);

					modfuncs->QuaternionSlerp(oq, nq, frac, ref.quat);
				}
				else
				{
					VectorScale(bone->quats[i].v, 1.f/32767, ref.quat);
					ref.quat[3] = 1 - DotProduct(ref.quat,ref.quat);
					if (ref.quat[3] > 0)
						ref.quat[3] = sqrt(ref.quat[3]);
				}

				for (i = 0; i < bone->numcoords; i++)
					if (ts < bone->coord[i].ts)
						break;
				if (!i--)
					;	//use the value from the model.
				else if (i < bone->numcoords-1 && bone->coord[i+1].ts == ts+1)
					VectorInterpolate(bone->coord[i].v, frac, bone->coord[i+1].v, ref.org);
				else
					VectorCopy(bone->coord[i].v, ref.org);

				break;	//don't look for others.
			}
		}
		modfuncs->GenMatrixPosQuat4Scale(ref.org, ref.quat, ref.scale, bonematrixstorage + b*12);
	}
	return bonematrixstorage;
}
static int Mod_XAnim_CompareEvents (const void *av, const void *bv)
{
	const galiasevent_t *a=av;
	const galiasevent_t *b=bv;
	return b->timestamp-a->timestamp;
}
static qboolean Mod_XAnim_Load (struct model_s *mod, void *buffer, size_t fsize)
{
	struct fstream_s f = {buffer, fsize};
	unsigned short ver = ReadUInt16(&f);
	unsigned short numposes = ReadUInt16(&f);
	unsigned short numabones=0, numrbones = ReadUInt16(&f);
	unsigned char flags = ReadByte(&f);
	unsigned short framerate = ReadUInt16(&f);
	unsigned int i;
	const qbyte *flip, *tiny;
	struct codbone_s *bone;
	galiasinfo_t *surf;
	galiasanimation_t *anim;
	galiasbone_t *gbones;
	int numev;
	switch(ver)
	{
	case 0x0e:	//cod1
		break;
	case 0x14:
		break;
	default:
		Con_Printf(CON_ERROR"%s: unknown version %x\n", mod->name, ver);
		return false;
	}
//	Con_Printf(CON_DEBUG"Poses:%i bones:%i flags:%i rate:%i\n", numposes, numrbones, flags, framerate);

	if (flags & 2)
		numabones = 1;

	mod->type = mod_alias;
	mod->fromgame = fg_new;
	mod->meshinfo = surf = plugfuncs->GMalloc(&mod->memgroup, sizeof(*surf) + sizeof(*anim) + sizeof(*bone)*(numabones+numrbones));
	surf->numbones = numabones+numrbones;
	surf->ofsbones = gbones = plugfuncs->GMalloc(&mod->memgroup, sizeof(*gbones)*(numabones+numrbones));

	surf->numanimations = 1;
	surf->ofsanimations = anim = (void*)(surf+1);

	anim->loop = !!(flags&1);
	anim->numposes = numposes;
	anim->skeltype = SKEL_RELATIVE;	//no parents info stored here, so these are screwy unless you're importing them into a model that DOES provide the parents info for you.
	bone = (void*)(anim+1);
	anim->rate = framerate;
	Q_strlcpy(anim->name, mod->name, sizeof(anim->name));
	anim->GetRawBones = Mod_XAnim_GetRawBones;

	for (i = 0; i < numabones; i++)
	{
		gbones[i].parent = -1;
		VectorClear(gbones[i].ref.org);
		Vector4Set(gbones[i].ref.quat,0,0,0,1);
		VectorSet(gbones[i].ref.scale,1,1,1);
		Q_strlcpy(gbones[i].name, "tag_origin", sizeof(gbones[i].name));

		Mod_XAnim_LoadQuats(mod, &f, &bone[i], numposes, false, true);
		Mod_XAnim_LoadCoords(mod, &f, &bone[i], numposes);
	}
	flip = ReadBytes(&f, (numrbones+7)>>3);
	tiny = ReadBytes(&f, (numrbones+7)>>3);
	if (anim->loop)
		numposes++;	//is this the right place?
	for (i = 0; i < numrbones; i++)
	{
		const char *n = ReadString(&f);
		gbones[numabones+i].parent = -1;	//no information. oh noes.
		VectorClear(gbones[i].ref.org);
		Vector4Set(gbones[i].ref.quat,0,0,0,1);
		VectorSet(gbones[i].ref.scale,1,1,1);
		Q_strlcpy(gbones[numabones+i].name, n, sizeof(gbones[numabones+i].name));
//		Con_Printf(CON_DEBUG"Part %i = %s (%i %i)\n", numabones+i, bone[numabones+i].name, !!(flip[i>>3]&(1u<<(i&7))), !!(tiny[i>>3]&(1u<<(i&7))));
	}
	for (i = 0; i < numrbones; i++)
	{
//		Con_Printf(CON_WARNING"%s:\n", gbones[numabones+i].name);
		Mod_XAnim_LoadQuats(mod, &f, &bone[numabones+i], numposes, !!(flip[i>>3]&(1u<<(i&7))), !!(tiny[i>>3]&(1u<<(i&7))));
		Mod_XAnim_LoadCoords(mod, &f, &bone[numabones+i], numposes);
	}
	if (anim->loop)
		numposes--;

	numev = ReadByte(&f);
	if (numev)
	{
		anim->events = plugfuncs->GMalloc(&mod->memgroup, sizeof(*anim->events)*(numev));
		for (i = 0; i < numev; i++)
		{
			const char *txt = ReadString(&f);
			anim->events[i].code = 0;	//this format doesn't provide event ids, just pure strings.
			anim->events[i].data = strcpy(plugfuncs->GMalloc(&mod->memgroup, strlen(txt)+1), txt);

			anim->events[i].timestamp = ReadUInt16(&f) / (float)numposes;
		}
		qsort(anim->events, numev, sizeof(*anim->events), Mod_XAnim_CompareEvents);	//make sure they're sorted by timestamps.
		for (i = 0; i < numev-1; i++)
			anim->events[i].next = &anim->events[i+1];
	}

	if (f.ofs != f.len)
		Con_Printf(CON_WARNING"Misread %s (%u bytes of %u)\n", mod->name, (unsigned)f.ofs, (unsigned)f.len);
	return true;
}
qboolean QDECL Mod_XModel_Load (struct model_s *mod, void *buffer, size_t fsize)
{
	struct fstream_s f = {buffer, fsize};
	struct fstream_s pf = {NULL,0};
	unsigned short ver;
	unsigned i;
	unsigned int clod, clodnsurf;
	unsigned short t;
	struct lod_s lod[4];
	float mincov = 0;
	int nlod;

	//I fucking hate this.
	if (!strncmp(mod->publicname, "xanim/", 6))	//anims are not linked in any way, we treat them as separate precachable models so that gamecode can selectively load them.
		return Mod_XAnim_Load(mod, buffer, fsize);
	if (!strncmp(mod->publicname, "xmodelparts/", 12))	//loaded as part of models. don't get confused.
		return false;
	if (!strncmp(mod->publicname, "xmodelsurfs/", 12))	//loaded as part of models. don't get confused.
		return false;
	//"xmodels/" is okay though!

	ver = ReadUInt16(&f);
	switch(ver)
	{
	case 0x0e:	//cod1
		nlod = 3;
		break;
	case 0x14:	//cod2
		/*type =*/ ReadByte(&f);
		nlod = 4;
		break;
	default:
		Con_Printf(CON_ERROR"%s: Unknown version %x\n", mod->name, ver);
		return false;
	}
	mod->mins[0] = ReadFloat(&f);
	mod->mins[1] = ReadFloat(&f);
	mod->mins[2] = ReadFloat(&f);
	mod->maxs[0] = ReadFloat(&f);
	mod->maxs[1] = ReadFloat(&f);
	mod->maxs[2] = ReadFloat(&f);
	for (i = 0; i < nlod; i++)
	{
		lod[i].coverage = ReadFloat(&f);	//coverage
		lod[i].name = ReadString(&f);
	}
	clod = ReadUInt32(&f);
	clodnsurf = ReadUInt32(&f);
	(void)clod;
	for (i = 0; i < clodnsurf && !ReadEOF(&f); i++)
	{
		unsigned int t, ntris = ReadUInt32(&f);
		for (t = 0; t < ntris && !ReadEOF(&f); t++)
		{
			vec4_t p, sd, td;
			//plane
			p[0] = ReadFloat(&f);
			p[1] = ReadFloat(&f);
			p[2] = ReadFloat(&f);
			p[3] = ReadFloat(&f);

			//?splane?
			sd[0] = ReadFloat(&f);
			sd[1] = ReadFloat(&f);
			sd[2] = ReadFloat(&f);
			sd[3] = ReadFloat(&f);

			//?tplane?
			td[0] = ReadFloat(&f);
			td[1] = ReadFloat(&f);
			td[2] = ReadFloat(&f);
			td[3] = ReadFloat(&f);

			(void)p;
			(void)sd;
			(void)td;

//			Con_Printf("%i: %f %f %f %f : %f %f %f %f : %f %f %f %f\n", t, p[0],p[1],p[2],p[3], sd[0],sd[1],sd[2],sd[3], td[0],td[1],td[2],td[3]);
			//dunno how to use this for collision... a triangle has 3 side faces AND a front!
		}
		//bounds
		ReadFloat(&f);
		ReadFloat(&f);
		ReadFloat(&f);
		ReadFloat(&f);
		ReadFloat(&f);
		ReadFloat(&f);
		/*boneidx = */ ReadUInt32(&f);
		/*contents = */ ReadUInt32(&f);
		/*surfaceflags = */ ReadUInt32(&f);
	}

	pf.ofs = 0;
	pf.start = filefuncs->LoadFile(va("xmodelparts/%s", lod[0].name), &pf.len);
	if (pf.start)
	{
		if (!ReadEOF(&pf) && Mod_XModel_LoadPart(mod, &pf))
		{
			if (pf.ofs != pf.len)
				Con_Printf(CON_WARNING"Misread xmodelparts/%s (%u bytes of %u)\n", lod[0].name, (unsigned)f.ofs, (unsigned)f.len);
		}
		else
			return false;
		plugfuncs->Free(pf.start);
	}

	for (i = 0; i < nlod; i++)
	{
		if (!*lod[i].name)
			break;
		lod[i].numtex = ReadUInt16(&f);
		for (t = 0; t < lod[i].numtex; t++)
			lod[i].tex[t] = ReadString(&f);
		pf.ofs = 0;
		pf.start = filefuncs->LoadFile(va("xmodelsurfs/%s", lod[i].name), &pf.len);
		if (pf.start)
		{
			if (!ReadEOF(&pf) && Mod_XModel_LoadSurfs(mod, &pf, &lod[i], mincov))
			{
				if (pf.ofs != pf.len)
					Con_Printf(CON_WARNING"Misread xmodelsurfs/%s (%u bytes of %u)\n", lod[i].name, (unsigned)f.ofs, (unsigned)f.len);
			}
			else
				return false;
			mincov = lod[i].coverage;
			plugfuncs->Free(pf.start);
		}
	}


	mod->type = mod_alias;
	mod->fromgame = fg_new;
	mod->radius = RadiusFromBounds(mod->mins, mod->maxs);
//	if (mod->meshinfo)
//		modfuncs->BIH_BuildAlias(mod, mod->meshinfo);
	return !!mod->meshinfo;
}

static qboolean XMODEL_Init(void)
{
	filefuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*filefuncs));
	modfuncs = plugfuncs->GetEngineInterface(plugmodfuncs_name, sizeof(*modfuncs));
	if (modfuncs && modfuncs->version != MODPLUGFUNCS_VERSION)
		modfuncs = NULL;

	if (modfuncs && filefuncs)
	{
		modfuncs->RegisterModelFormatMagic("XMODEL", "\x0e\0",2, Mod_XModel_Load);	//cod1
		modfuncs->RegisterModelFormatMagic("XMODEL", "\x14\0",2, Mod_XModel_Load);	//cod2
		return true;
	}
	return false;
}


qboolean CODBSP_Init(void);
qboolean STypes_Init(void);
qboolean IWI_Init(void);
//qboolean IWFF_Init(void);

qboolean Plug_Init(void)
{
	qboolean somethingisokay = false;
	char plugname[128];
	strcpy(plugname, "cod");
	plugfuncs->GetPluginName(0, plugname, sizeof(plugname));

	if (!STypes_Init())	Con_Printf(CON_ERROR"%s: Shader Types support unavailable\n",	plugname);	else	somethingisokay = true;
	if (!IWI_Init())	Con_Printf(CON_ERROR"%s: IWI support unavailable\n",			plugname);	else	somethingisokay = true;
	if (!XMODEL_Init())	Con_Printf(CON_ERROR"%s: XModel support unavailable\n",			plugname);	else	somethingisokay = true;
	if (!CODBSP_Init())	Con_Printf(CON_ERROR"%s: CODBSP support unavailable\n",			plugname);	else	somethingisokay = true;
//	if (!IWFF_Init())	Con_Printf(CON_ERROR"%s: FF support unavailable\n",				plugname);	else	somethingisokay = true;
	return somethingisokay;
}