fteqw/engine/client/pr_skelobj.c

/*
Copyright (C) 2011 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
/*
this file deals with qc builtins to apply custom skeletal blending (skeletal objects extension), as well as the logic required to perform realtime ragdoll, if I ever implement that.
*/

/*
skeletal objects are just a set of bone poses.
they are separate from the entity they are attached to, and must be created/destroyed separately.
typically the bones are all stored relative to their parent.
qc must use skel_build to copy animation data from the file format into the skeletal object for rendering, but can build different bones using different animations or can override explicit bones.

ragdoll file is a description of the joints in the ragdoll.
a skeletal object, built from a doll instead of a model, has a series of physics objects created at key points (ie: not face).
these objects are absolute
qc must build the skeletal object still, which fills the skeletal object from the physics objects instead of animation data, for bones that have solid objects.
*/

#include "quakedef.h"

qboolean Mod_FrameInfoForNum(model_t *model, int num, char **name, int *numframes, float *duration, qboolean *loop);
const char *Mod_SkinNameForNum(model_t *model, int num);

#if defined(RAGDOLL) || defined(SKELETALOBJECTS)

#include "pr_common.h"
#include "com_mesh.h"

#define MAX_SKEL_OBJECTS 1024

#ifdef RAGDOLL
/*this is the description of the ragdoll, it is how the doll flops around*/
typedef struct doll_s
{
	char *name;
	int uses;
	model_t *model;
	struct doll_s *next;

	qboolean drawn:1;
	int numdefaultanimated;
	int numbodies;
	int numjoints;
	int numbones;
	odebodyinfo_t *body;
	odejointinfo_t *joint;
	struct
	{
		//easy lookup table for bone->body.
		//most of these will be -1, which means 'import from animation object'
		int bodyidx;
	} *bone;
} doll_t;

typedef struct
{
	odebody_t odebody;

//	int ownerent;	/*multiple of 12*/
//	int flags;

//	float moment[12];
	float animstrength;
	float animmatrix[12];
} body_t;
#endif

/*this is the skeletal object*/
typedef struct skelobject_s
{
	int inuse;

	model_t *model;
	world_t *world; /*be it ssqc or csqc*/
	skeltype_t type;

	unsigned int numbones;
	float *bonematrix;

#ifdef RAGDOLL
	int numanimated;
	struct skelobject_s *animsource;
	unsigned int numbodies;
	body_t *body;
	int numjoints;
	odejoint_t *joint;
	doll_t *doll;
	wedict_t *entity;	//only valid for dolls.
#endif
} skelobject_t;

#ifdef RAGDOLL
static doll_t *dolllist;
#endif
static skelobject_t skelobjects[MAX_SKEL_OBJECTS];
static int numskelobjectsused;

//copes with src==dst to convert rel->abs
void skel_copy_toabs(skelobject_t *skelobjdst, skelobject_t *skelobjsrc, int startbone, int endbone)
{
	int maxbones;
	galiasbone_t *boneinfo = Mod_GetBoneInfo(skelobjsrc->model, &maxbones);
	if (!boneinfo)
		return;
	endbone = min(endbone, maxbones-1);
	if (skelobjsrc->type == SKEL_ABSOLUTE)
	{
		if (skelobjsrc != skelobjdst)
		{
			while(startbone < endbone)
			{
				Vector4Copy(skelobjsrc->bonematrix+12*startbone+0, skelobjdst->bonematrix+12*startbone+0);
				Vector4Copy(skelobjsrc->bonematrix+12*startbone+4, skelobjdst->bonematrix+12*startbone+4);
				Vector4Copy(skelobjsrc->bonematrix+12*startbone+8, skelobjdst->bonematrix+12*startbone+8);
				startbone++;
			}
		}
	}
	else
	{
		if (skelobjsrc != skelobjdst)
		{
			while(startbone < endbone)
			{
				if (boneinfo[startbone].parent >= 0)
				{
					Matrix3x4_Multiply(skelobjsrc->bonematrix+12*startbone, skelobjdst->bonematrix+12*boneinfo[startbone].parent, skelobjdst->bonematrix+12*startbone);
				}
				else
				{
					Vector4Copy(skelobjsrc->bonematrix+12*startbone+0, skelobjdst->bonematrix+12*startbone+0);
					Vector4Copy(skelobjsrc->bonematrix+12*startbone+4, skelobjdst->bonematrix+12*startbone+4);
					Vector4Copy(skelobjsrc->bonematrix+12*startbone+8, skelobjdst->bonematrix+12*startbone+8);
				}
				startbone++;
			}
		}
		else
		{
			float tmpmat[12];
			while(startbone < endbone)
			{
				if (boneinfo[startbone].parent >= 0)
				{
					Matrix3x4_Multiply(skelobjsrc->bonematrix+12*startbone, skelobjdst->bonematrix+12*boneinfo[startbone].parent, tmpmat);
					memcpy(skelobjdst->bonematrix+12*startbone, tmpmat, sizeof(tmpmat));
				}
				startbone++;
			}
		}
	}

	skelobjdst->type = SKEL_ABSOLUTE;
}
static void bonemat_fromidentity(float *out)
{
	out[0] = 1;
	out[1] = 0;
	out[2] = 0;
	out[3] = 0;

	out[4] = 0;
	out[5] = 1;
	out[6] = 0;
	out[7] = 0;

	out[8] = 0;
	out[9] = 0;
	out[10] = 1;
	out[11] = 0;
}
static void bonemat_fromqcvectors(float *out, const float vx[3], const float vy[3], const float vz[3], const float t[3])
{
	out[0] = vx[0];
	out[1] = -vy[0];
	out[2] = vz[0];
	out[3] = t[0];
	out[4] = vx[1];
	out[5] = -vy[1];
	out[6] = vz[1];
	out[7] = t[1];
	out[8] = vx[2];
	out[9] = -vy[2];
	out[10] = vz[2];
	out[11] = t[2];
}
static void bonemat_fromaxisorg(float *out, vec3_t axis[3], const float t[3])
{
	out[0] = axis[0][0];
	out[1] = axis[1][0];
	out[2] = axis[2][0];
	out[3] = t[0];
	out[4] = axis[0][1];
	out[5] = axis[1][1];
	out[6] = axis[2][1];
	out[7] = t[1];
	out[8] = axis[0][2];
	out[9] = axis[1][2];
	out[10]= axis[2][2];
	out[11]= t[2];
}
static void bonemat_fromentity(world_t *w, wedict_t *ed, float *trans)
{
	vec3_t d[3], a;
	model_t *mod;
	mod = w->Get_CModel(w, ed->v->modelindex);
	if (!mod || mod->type == mod_alias)
		a[0] = -ed->v->angles[0];
	else
		a[0] = ed->v->angles[0];
	a[1] = ed->v->angles[1];
	a[2] = ed->v->angles[2];
	AngleVectors(a, d[0], d[1], d[2]);
	bonemat_fromqcvectors(trans, d[0], d[1], d[2], ed->v->origin);
}
static void bonemat_toqcvectors(const float *in, float vx[3], float vy[3], float vz[3], float t[3])
{
	vx[0] = in[0];
	vx[1] = in[4];
	vx[2] = in[8];
	vy[0] = -in[1];
	vy[1] = -in[5];
	vy[2] = -in[9];
	vz[0] = in[2];
	vz[1] = in[6];
	vz[2] = in[10];
	t [0] = in[3];
	t [1] = in[7];
	t [2] = in[11];
}

static void bonematident_toqcvectors(float vx[3], float vy[3], float vz[3], float t[3])
{
	vx[0] = 1;
	vx[1] = 0;
	vx[2] = 0;
	vy[0] = -0;
	vy[1] = -1;
	vy[2] = -0;
	vz[0] = 0;
	vz[1] = 0;
	vz[2] = 1;
	t [0] = 0;
	t [1] = 0;
	t [2] = 0;
}


static qboolean pendingkill; /*states that there is a skel waiting to be killed*/
#ifdef RAGDOLL
static void rag_uninstanciate(skelobject_t *sko);
static int rag_finddollbody(doll_t *d, char *bodyname)
{
	int i;
	for (i = 0; i < d->numbodies; i++)
	{
		if (!strcmp(d->body[i].name, bodyname))
			return i;
	}
	return -1;
}
static int rag_finddolljoint(doll_t *d, char *name)
{
	int i;
	for (i = 0; i < d->numjoints; i++)
	{
		if (!strcmp(d->joint[i].name, name))
			return i;
	}
	return -1;
}

typedef struct {
	qboolean errors;
	doll_t *d;
	int numbones;
	galiasbone_t *bones;

	odebodyinfo_t *body;
	odejointinfo_t *joint;

	odebodyinfo_t defbody;
	odejointinfo_t defjoint;
} dollcreatectx_t;
static dollcreatectx_t *rag_createdoll(model_t *mod, const char *fname, int numbones)
{
	int i;
	dollcreatectx_t *ctx;
	int nummodbones = Mod_GetNumBones(mod, false);
	if (nummodbones != numbones || !numbones)
		return NULL;

	ctx = malloc(sizeof(*ctx));

	ctx->bones = Mod_GetBoneInfo(mod, &ctx->numbones);
	ctx->errors = 0;

	memset(&ctx->defbody, 0, sizeof(ctx->defbody));
	ctx->defbody.animate = true;
	ctx->defbody.geomshape = GEOMTYPE_BOX;
	ctx->defbody.dimensions[0] = 4;
	ctx->defbody.dimensions[1] = 4;
	ctx->defbody.dimensions[2] = 4;
	ctx->defbody.mass = 1;
	ctx->defbody.orient = false;

	memset(&ctx->defjoint, 0, sizeof(ctx->defjoint));
	ctx->defjoint.axis[1] = 1;
	ctx->defjoint.axis2[2] = 1;
	ctx->defjoint.ERP = 0.2;	//use ODE defaults
	ctx->defjoint.ERP2 = 0.2;
	ctx->defjoint.CFM = 1e-5;
	ctx->defjoint.CFM2 = 1e-5;

	ctx->d = BZ_Malloc(sizeof(*ctx->d));
	ctx->d->next = dolllist;
	ctx->d->name = strdup(fname);
	ctx->d->model = mod;
	ctx->d->numbodies = 0;
	ctx->d->body = NULL;
	ctx->d->numjoints = 0;
	ctx->d->uses = 0;
	ctx->d->joint = NULL;

	ctx->d->numbones = min(numbones, ctx->numbones);
	ctx->d->bone = BZ_Malloc(sizeof(*ctx->d->bone) * ctx->d->numbones);
	for (i = 0; i < ctx->d->numbones; i++)
		ctx->d->bone[i].bodyidx = -1;

	return ctx;
}
//returns true if the command was recognised. false if the command is for something else.
static qboolean rag_dollline(dollcreatectx_t *ctx, int linenum)
{
	int i;
	int argc;
	char *cmd, *val;
	doll_t *d = ctx->d;

	argc = Cmd_Argc();
	cmd = Cmd_Argv(0);
	val = Cmd_Argv(1);

	if (!argc)
	{
	}
	//create a new body
	else if (argc == 3 && !stricmp(cmd, "body"))
	{
		int boneidx = Mod_TagNumForName(d->model, Cmd_Argv(2))-1;
		ctx->joint = NULL;
		ctx->body = NULL;
		if (boneidx >= 0)
		{
			d->body = BZ_Realloc(d->body, sizeof(*d->body)*(d->numbodies+1));
			ctx->body = &d->body[d->numbodies];
			d->bone[boneidx].bodyidx = d->numbodies;
			d->numbodies++;

			*ctx->body = ctx->defbody;
			Q_strncpyz(ctx->body->name, Cmd_Argv(1), sizeof(ctx->body->name));
			ctx->body->bone = boneidx;
		}
		else if (!ctx->errors++)
			Con_Printf("^[Unable to create body \"%s\" because bone \"%s\" does not exist in %s\\edit\\%s %i^]\n", Cmd_Argv(1), Cmd_Argv(2), d->model->name, d->name, linenum);
	}
	//create a new joint
	else if (argc >= 2 && !stricmp(cmd, "joint"))
	{
		char *name;
		ctx->joint = NULL;
		ctx->body = NULL;
		d->joint = BZ_Realloc(d->joint, sizeof(*d->joint)*(d->numjoints+1));
		ctx->joint = &d->joint[d->numjoints];
		*ctx->joint = ctx->defjoint;
		Q_strncpyz(ctx->joint->name, Cmd_Argv(1), sizeof(ctx->joint->name));
		name = Cmd_Argv(2);
		ctx->joint->body1 = *name?rag_finddollbody(d, name):-1;
		if (*name && ctx->joint->body1 < 0)
		{
			if (!ctx->errors++)
				Con_Printf("^[Joint \"%s\" joins invalid body \"%s\"\\edit\\%s %i^]\n", ctx->joint->name, name, d->name, linenum);
			return true;
		}
		name = Cmd_Argv(3);
		ctx->joint->body2 = *name?rag_finddollbody(d, name):-1;
		if (*name && (ctx->joint->body2 < 0 || ctx->joint->body2 == ctx->joint->body1))
		{
			if (!ctx->errors++)
			{
				if (ctx->joint->body2 == ctx->joint->body1)
					Con_Printf("^[Joint \"%s\" joints body \"%s\" to itself\\edit\\%s %i^]\n", ctx->joint->name, name, d->name, linenum);
				else
					Con_Printf("^[Joint \"%s\" joints invalid body \"%s\"\\edit\\%s %i^]\n", ctx->joint->name, name, d->name, linenum);
			}
			return true;
		}
		ctx->joint->bonepivot = d->body[(ctx->joint->body2 >= 0)?ctx->joint->body2:ctx->joint->body1].bone;	//default the pivot object to the bone of the second object.

		if (ctx->joint->body1 >= 0 || ctx->joint->body2 >= 0)
			d->numjoints++;
		else if (!ctx->errors++)
			Con_Printf("^[Joint property \"%s\" not recognised\\edit\\%s %i^]\n", ctx->joint->name, d->name, linenum);
	}
	else if (argc == 2 && !stricmp(cmd, "updatebody"))
	{
		ctx->joint = NULL;
		ctx->body = NULL;
		if (!strcmp(val, "default"))
			ctx->body = &ctx->defbody;
		else
		{
			i = rag_finddollbody(d, val);
			if (i >= 0)
				ctx->body = &d->body[i];
			else if (!ctx->errors++)
				Con_Printf("^[Cannot update body \"%s\"\\edit\\%s %i^]\n", ctx->body->name, d->name, linenum);
		}
	}
	else if (argc == 2 && !stricmp(cmd, "updatejoint"))
	{
		ctx->joint = NULL;
		ctx->body = NULL;
		if (!strcmp(val, "default"))
			ctx->joint = &ctx->defjoint;
		else
		{
			i = rag_finddolljoint(d, val);
			if (i >= 0)
				ctx->joint = &d->joint[i];
			else if (!ctx->errors++)
				Con_Printf("^[Cannot update joint \"%s\"\\edit\\%s %i^]\n", ctx->joint->name, d->name, linenum);
		}
	}

	//body properties
	else if (ctx->body && argc == 2 && !stricmp(cmd, "shape"))
	{
		if (!stricmp(val, "box"))
			ctx->body->geomshape = GEOMTYPE_BOX;
		else if (!stricmp(val, "sphere"))
			ctx->body->geomshape = GEOMTYPE_SPHERE;
		else if (!stricmp(val, "cylinder"))
			ctx->body->geomshape = GEOMTYPE_CYLINDER;
		else if (!stricmp(val, "capsule"))
			ctx->body->geomshape = GEOMTYPE_CAPSULE;
		else if (!ctx->errors++)
			Con_Printf("^[Joint shape \"%s\" not recognised\\edit\\%s %i^]\n", val, d->name, linenum);
	}
	else if (ctx->body && argc == 2 && !stricmp(cmd, "animate"))
		ctx->body->animate = atof(val);
	else if (ctx->body && argc == 2 && !stricmp(cmd, "draw"))
		ctx->body->draw = atoi(val);
	else if (ctx->body && argc == 2 && !stricmp(cmd, "mass"))
		ctx->body->mass = atof(val);
	else if (ctx->body && argc == 2 && (!stricmp(cmd, "dimensions") || !stricmp(cmd, "size")))
		ctx->body->dimensions[0] = ctx->body->dimensions[1] = ctx->body->dimensions[2] = atof(val);
	else if (ctx->body && argc == 3 && (!stricmp(cmd, "dimensions") || !stricmp(cmd, "size")))
	{
		ctx->body->dimensions[0] = ctx->body->dimensions[1] = atof(val);
		ctx->body->dimensions[2] = atoi(Cmd_Argv(2));
	}
	else if (ctx->body && argc == 4 && (!stricmp(cmd, "dimensions") || !stricmp(cmd, "size")))
	{
		ctx->body->dimensions[0] = atof(val);
		ctx->body->dimensions[1] = atof(Cmd_Argv(2));
		ctx->body->dimensions[2] = atof(Cmd_Argv(3));
	}

	//joint properties
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "type"))
	{
		if (!stricmp(val, "fixed"))
			ctx->joint->type = JOINTTYPE_FIXED;
		else if (!stricmp(val, "point"))
			ctx->joint->type = JOINTTYPE_POINT;
		else if (!stricmp(val, "hinge"))
			ctx->joint->type = JOINTTYPE_HINGE;
		else if (!stricmp(val, "slider"))
			ctx->joint->type = JOINTTYPE_SLIDER;
		else if (!stricmp(val, "universal"))
			ctx->joint->type = JOINTTYPE_UNIVERSAL;
		else if (!stricmp(val, "hinge2"))
			ctx->joint->type = JOINTTYPE_HINGE2;
	}
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "draw"))
		ctx->joint->draw = atoi(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "ERP"))
		ctx->joint->ERP = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "ERP2"))
		ctx->joint->ERP2 = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "CFM"))
		ctx->joint->CFM = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "CFM2"))
		ctx->joint->CFM2 = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "FMax"))
		ctx->joint->FMax = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "FMax2"))
		ctx->joint->FMax2 = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "HiStop"))
		ctx->joint->HiStop = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "HiStop2"))
		ctx->joint->HiStop2 = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "LoStop"))
		ctx->joint->LoStop = atof(val);
	else if (ctx->joint && argc == 2 && !stricmp(cmd, "LoStop2"))
		ctx->joint->LoStop2 = atof(val);
	else if (ctx->joint && argc == 4 && !stricmp(cmd, "axis"))
	{
		ctx->joint->axis[0] = atof(val);
		ctx->joint->axis[1] = atof(Cmd_Argv(2));
		ctx->joint->axis[2] = atof(Cmd_Argv(3));
	}
	else if (ctx->joint && argc == 4 && !stricmp(cmd, "axis2"))
	{
		ctx->joint->axis2[0] = atof(val);
		ctx->joint->axis2[1] = atof(Cmd_Argv(2));
		ctx->joint->axis2[2] = atof(Cmd_Argv(3));
	}
	else if (ctx->joint && argc == 4 && !stricmp(cmd, "offset"))
	{
		ctx->joint->offset[0] = atof(val);
		ctx->joint->offset[1] = atof(Cmd_Argv(2));
		ctx->joint->offset[2] = atof(Cmd_Argv(3));
	}
	else if (ctx->joint && ctx->joint != &ctx->defjoint && (argc == 2 || argc == 5) && !stricmp(cmd, "pivot"))
	{
		//the origin is specified in base-frame model space
		//we need to make it relative to the joint's bodies
		char *bone = val;
		i = Mod_TagNumForName(d->model, bone)-1;
		if (argc > 2)
		{
			ctx->joint->offset[0] = atof(Cmd_Argv(2));
			ctx->joint->offset[1] = atof(Cmd_Argv(3));
			ctx->joint->offset[2] = atof(Cmd_Argv(4));
		}
		if (i >= 0)
		{
			ctx->joint->bonepivot = i;
			//Matrix3x4_Multiply(omat, bones[i].inverse, joint->orgmatrix);
		}
		else if (!ctx->errors++)
			Con_Printf("^[Directive \"%s\" not understood or invalid\\edit\\%s %i^]\n", cmd, d->name, linenum);
	}
	else
		return false;

	return true;
};
static doll_t *rag_finishdoll(dollcreatectx_t *ctx)
{
	doll_t *d = ctx->d;
	int i;

	d->drawn = false;
	for (i = 0; i < d->numbodies; i++)
	{
		if (d->body[i].draw)
		{
			d->drawn = true;
			break;
		}
	}
	if (i == d->numbodies)
	for (i = 0; i < d->numjoints; i++)
	{
		if (d->joint[i].draw)
		{
			d->drawn = true;
			break;
		}
	}

	free(ctx);

	if (!d->numbodies)
	{
		rag_freedoll(d);
		return NULL;
	}
	return d;
};

doll_t *rag_createdollfromstring(model_t *mod, const char *fname, int numbones, const char *file)
{
	int linenum = 0;
	dollcreatectx_t *ctx;
	ctx = rag_createdoll(mod, fname, numbones);
	if (!ctx)
		return NULL;
	
	while(file && *file)
	{
		linenum++;
		file = Cmd_TokenizeString(file, false, false);

		if (!rag_dollline(ctx, linenum))
			if (!ctx->errors++)
				Con_Printf("^[Directive \"%s\" not understood or invalid\\edit\\%s %i^]\n", Cmd_Argv(0), ctx->d->name, linenum);
	}
	return rag_finishdoll(ctx);
}

static doll_t *rag_loaddoll(model_t *mod, char *fname, int numbones)
{
	doll_t *d;
	void *fptr = NULL;

	for (d = dolllist; d; d = d->next)
	{
		if (d->model == mod)
			if (!strcmp(d->name, fname))
				return d;
	}

	FS_LoadFile(fname, &fptr);
	if (!fptr)
	{
#ifndef SERVERONLY
		CL_CheckOrEnqueDownloadFile(fname, NULL, 0);
#endif
		return NULL;
	}

	d = rag_createdollfromstring(mod, fname, numbones, fptr);
	FS_FreeFile(fptr);

	if (d)
	{
		d->next = dolllist;
		dolllist = d;
	}
	return d;
}
void rag_freedoll(doll_t *doll)
{
	int i;
	if (doll->uses)
	{
		for (i = 0; i < numskelobjectsused; i++)
		{
			if (skelobjects[i].doll == doll)
			{
				rag_uninstanciate(&skelobjects[i]);
				if (!doll->uses)
					break;
			}
		}
	}
	BZ_Free(doll->bone);
	BZ_Free(doll->body);
	BZ_Free(doll->joint);
	free(doll->name);
	BZ_Free(doll);
}

void rag_flushdolls(qboolean force)
{
	doll_t *d, **link;
	int i;
	if (force)
	{
		for (i = 0; i < numskelobjectsused; i++)
		{
			rag_uninstanciate(&skelobjects[i]);
		}
	}
	for (link = &dolllist; *link; )
	{
		d = *link;
		if (!d->uses)
		{
			*link = d->next;
			rag_freedoll(d);
		}
		else
			link = &(*link)->next;
	}
}

#if 0
static void skel_integrate(pubprogfuncs_t *prinst, skelobject_t *sko, skelobject_t *skelobjsrc, float ft, float mmat[12])
{
	trace_t t;
	vec3_t npos, opos, wnpos, wopos;
	vec3_t move;
	float wantmat[12];
	world_t *w = prinst->parms->user;
	body_t *b;
	float gravity = 800;
	int bone, bno;
	int boffs;
	galiasbone_t *boneinfo = Mod_GetBoneInfo(sko->model);
	if (!boneinfo)
		return;

	for (bone = 0, bno = 0, b = sko->body; bone < sko->numbones; bone++)
	{
		boffs = bone*12;
		/*if this bone is positioned using a physical body...*/
		if (bno < sko->numbodies && b->jointo == boffs)
		{
			if (skelobjsrc)
			{
				/*attempt to move to target*/
				if (boneinfo[bone].parent >= 0)
				{
					Matrix3x4_Multiply(skelobjsrc->bonematrix+boffs, sko->bonematrix+12*boneinfo[bone].parent, wantmat);
				}
				else
				{
					Vector4Copy(skelobjsrc->bonematrix+boffs+0, wantmat+0);
					Vector4Copy(skelobjsrc->bonematrix+boffs+4, wantmat+4);
					Vector4Copy(skelobjsrc->bonematrix+boffs+8, wantmat+8);
				}
				b->vel[0] = (wantmat[3 ] - sko->bonematrix[b->jointo + 3 ])/ft;
				b->vel[1] = (wantmat[7 ] - sko->bonematrix[b->jointo + 7 ])/ft;
				b->vel[2] = (wantmat[11] - sko->bonematrix[b->jointo + 11])/ft;
			}
			else
			{
				/*handle gravity*/
				b->vel[2] = b->vel[2] - gravity * ft / 2;
			}

			VectorScale(b->vel, ft, move);

			opos[0] = sko->bonematrix[b->jointo + 3 ];
			opos[1] = sko->bonematrix[b->jointo + 7 ];
			opos[2] = sko->bonematrix[b->jointo + 11];
			npos[0] = opos[0] + move[0];
			npos[1] = opos[1] + move[1];
			npos[2] = opos[2] + move[2];

			Matrix3x4_RM_Transform3(mmat, opos, wopos);
			Matrix3x4_RM_Transform3(mmat, npos, wnpos);

			t = World_Move(w, wopos, vec3_origin, vec3_origin, wnpos, MOVE_NOMONSTERS, w->edicts);
			if (t.startsolid)
				t.fraction = 1;
			else if (t.fraction < 1)
			{
				/*clip the velocity*/
				float backoff = -DotProduct (b->vel, t.plane.normal) * 1.9; /*teehee, bouncy corpses*/
				VectorMA(b->vel, backoff, t.plane.normal, b->vel);
			}
			if (skelobjsrc)
			{
				VectorCopy(wantmat+0, sko->bonematrix+b->jointo+0);
				VectorCopy(wantmat+4, sko->bonematrix+b->jointo+4);
				VectorCopy(wantmat+8, sko->bonematrix+b->jointo+8);
			}

			sko->bonematrix[b->jointo + 3 ] += move[0] * t.fraction;
			sko->bonematrix[b->jointo + 7 ] += move[1] * t.fraction;
			sko->bonematrix[b->jointo + 11] += move[2] * t.fraction;

			if (!skelobjsrc)
				b->vel[2] = b->vel[2] - gravity * ft / 2;

			b++;
			bno++;
		}
		else if (skelobjsrc)
		{
			/*directly copy animation skeleton*/
			if (boneinfo[bone].parent >= 0)
			{
				Matrix3x4_Multiply(skelobjsrc->bonematrix+boffs, sko->bonematrix+12*boneinfo[bone].parent, sko->bonematrix+boffs);
			}
			else
			{
				Vector4Copy(skelobjsrc->bonematrix+boffs+0, sko->bonematrix+boffs+0);
				Vector4Copy(skelobjsrc->bonematrix+boffs+4, sko->bonematrix+boffs+4);
				Vector4Copy(skelobjsrc->bonematrix+boffs+8, sko->bonematrix+boffs+8);
			}
		}
		else
		{
			/*retain the old relation*/
			/*FIXME*/
		}
	}
	/*debugging*/
#if 0
	/*draw points*/
	for (bone = 0; p < sko->numbones; bone++)
	{
		opos[0] = sko->bonematrix[bone*12 + 3 ];
		opos[1] = sko->bonematrix[bone*12 + 7 ];
		opos[2] = sko->bonematrix[bone*12 + 11];
		Matrix3x4_RM_Transform3(mmat, opos, wopos);
		P_RunParticleEffectTypeString(wopos, vec3_origin, 1, "ragdolltest");
	}
#endif
}
#endif
#endif

static void skel_generateragdoll_f_bones(vfsfile_t *f, galiasbone_t *bones, int numbones, int parent, int indent)
{
	int i, j;
	for (i = 0; i < numbones; i++)
	{
		if (bones[i].parent == parent)
		{
			VFS_PUTS(f, "//");
			for (j = 0; j < indent; j++)
				VFS_PUTS(f, "\t");
			VFS_PUTS(f, va("%i %s\n", i, bones[i].name));
			skel_generateragdoll_f_bones(f, bones, numbones, i, indent+1);
		}
	}
}
void skel_generateragdoll_f(void)
{
	char *modname = Cmd_Argv(1);
	char *outname;
	model_t *mod = Mod_ForName(modname, false);
	galiasbone_t *bones;
	vfsfile_t *f;
	int i;
	int numbones;
	if (!mod)
	{
		Con_Printf("Cannot open %s\n", modname);
		return;
	}
	bones = Mod_GetBoneInfo(mod, &numbones);
	if (!bones || numbones < 1)
	{
		Con_Printf("Model %s has no bones\n", modname);
		return;
	}
	outname = va("%s.doll", mod->name);
	
	f = FS_OpenVFS(outname, "wb", FS_GAMEONLY);
	VFS_PUTS(f, va("//basic ragdoll info for model %s\n", mod->name));
	VFS_PUTS(f, va("//generated with: %s %s\n", Cmd_Argv(0), Cmd_Args()));
	VFS_PUTS(f, "//this file will need editing by hand\n");
	VFS_PUTS(f, "//use the flush command to reload this file\n");

	//print background bone info.
	VFS_PUTS(f, "\n//bones are as follows:\n");
	skel_generateragdoll_f_bones(f, bones, numbones, -1, 0);

	//print background frame info.
	VFS_PUTS(f, "\n//frames are as follows:\n");
	for (i = 0; i < 32768; i++)
	{
		char *fname;
		int numframes;
		float duration;
		qboolean loop;
		if (!Mod_FrameInfoForNum(mod, i, &fname, &numframes, &duration, &loop))
			break;
		VFS_PUTS(f, va("//%i %s (%i frames) (%f secs)%s", i, fname, numframes, duration, loop?" (loop)":""));
	}
	if (i == 0)
		VFS_PUTS(f, "//NO FRAME INFO\n");

		//print background frame info.
	VFS_PUTS(f, "\n//skins are as follows:\n");
	for (i = 0; i < 32768; i++)
	{
		const char *sname;
		sname = Mod_SkinNameForNum(mod, i);
		if (!sname)
			break;
		VFS_PUTS(f, va("//%i %s", i, sname));
	}
	if (i == 0)
		VFS_PUTS(f, "//NO SKIN INFO\n");

	VFS_PUTS(f, "\nupdatebody default\n");
	VFS_PUTS(f, "\tshape box	//one of box, sphere, cylinder, capsule\n");
	VFS_PUTS(f, "\tdimensions 8 8 8\n");
	VFS_PUTS(f, "\tdraw 1		//1 for visualising debug, 0 for release\n");
	VFS_PUTS(f, "\tanimate 1	//0 will always be limp\n");
	VFS_PUTS(f, "\n");

	//FIXME: only write out the bodies specified as arguments, and with no //
	for (i = 0; i < numbones; i++)
		VFS_PUTS(f, va("//body b_%s %s\n", bones[i].name, bones[i].name));
	VFS_PUTS(f, "\n");

	VFS_PUTS(f, "updatejoint default\n");
	VFS_PUTS(f, "\ttype hinge	//one of fixed, point, hinge, slider, universal, hinge2\n");
	VFS_PUTS(f, "\t//histop 1\n");
	VFS_PUTS(f, "\t//lostop -1\n");
	VFS_PUTS(f, "\t//histop2 1\n");
	VFS_PUTS(f, "\t//lostop2 -1\n");
	VFS_PUTS(f, "\t//erp\n");
	VFS_PUTS(f, "\t//erp2\n");
	VFS_PUTS(f, "\t//cfm\n");
	VFS_PUTS(f, "\t//cfm2\n");
	VFS_PUTS(f, "\t//fmax\n");
	VFS_PUTS(f, "\t//fmax2\n");
	VFS_PUTS(f, "\n");

	for (i = 0; i < numbones; i++)
	{
		if (bones[i].parent >= 0)	//don't generate joints for root bones. FIXME: also skip omitted bodies from argument list.
		{
			VFS_PUTS(f, va("//joint j_%s b_%s b_%s\n", bones[i].name, bones[bones[i].parent].name, bones[i].name));
			//FIXME: calc the extents in each pose and set the hi/lo stops.
		}
	}
	VFS_PUTS(f, "\n");

	VFS_CLOSE(f);
}
void skel_info_f(void)
{
	int i;
	for (i = 0; i < numskelobjectsused; i++)
	{
		if (skelobjects[i].world)
		{
			extern world_t csqc_world;
			Con_Printf("doll %i:\n", i);
#ifndef CLIENTONLY
			if (skelobjects[i].world == &sv.world)
				Con_Printf(" SSQC\n");
#endif
#ifndef SERVERONLY
			if (skelobjects[i].world == &csqc_world)
				Con_Printf(" CSQC\n");
#endif
			Con_Printf(" type: %s\n", (skelobjects[i].type == SKEL_RELATIVE)?"parentspace":"modelspace");
			Con_Printf(" model: %s\n", skelobjects[i].model->name);
			Con_Printf(" bone count: %i\n", skelobjects[i].numbones);
#ifdef RAGDOLL
			if (skelobjects[i].doll)
			{
				Con_Printf(" ragdoll: %s%s\n", skelobjects[i].doll->name, ((skelobjects[i].doll == skelobjects[i].model->dollinfo)?" (model default)":""));
				Con_Printf(" phys bodies: %i\n", skelobjects[i].doll->numbodies);
			}
			if (skelobjects[i].entity)
				Con_Printf(" entity: %i (%s)\n", skelobjects[i].entity->entnum, skelobjects[i].world->progs->StringToNative(skelobjects[i].world->progs, skelobjects[i].entity->v->classname));
#endif
		}
	}
}

/*destroys all skeletons*/
void skel_reset(pubprogfuncs_t *prinst)
{
	int i;

	for (i = 0; i < numskelobjectsused; i++)
	{
		if (skelobjects[i].world == prinst->parms->user)
		{
#ifdef RAGDOLL
			rag_uninstanciate(&skelobjects[i]);
#endif
			skelobjects[i].numbones = 0;
			skelobjects[i].inuse = false;
			skelobjects[i].bonematrix = NULL;
		}
	}

	while (numskelobjectsused && !skelobjects[numskelobjectsused-1].inuse)
		numskelobjectsused--;
#ifdef RAGDOLL
	rag_flushdolls(false);
#endif
}

/*deletes any skeletons marked for deletion*/
void skel_dodelete(pubprogfuncs_t *prinst)
{
	int skelidx;
	if (!pendingkill)
		return;

	pendingkill = false;
	for (skelidx = 0; skelidx < numskelobjectsused; skelidx++)
	{
		if (skelobjects[skelidx].inuse == 2)
		{
#ifdef RAGDOLL
			rag_uninstanciate(&skelobjects[skelidx]);
#endif
			skelobjects[skelidx].inuse = 0;
		}
	}

	while (numskelobjectsused && !skelobjects[numskelobjectsused-1].inuse)
		numskelobjectsused--;
}

static skelobject_t *skel_create(pubprogfuncs_t *prinst, int bonecount)
{
	unsigned int skelidx;
	//invalid if the bonecount is not set...
	if (bonecount <= 0 || bonecount > MAX_BONES)
		return NULL;

	for (skelidx = 0; skelidx < numskelobjectsused; skelidx++)
	{
		if (!skelobjects[skelidx].inuse && skelobjects[skelidx].numbones == bonecount && skelobjects[skelidx].world == prinst->parms->user)
		{
			skelobjects[skelidx].inuse = 1;
			return &skelobjects[skelidx];
		}
	}

	for (skelidx = 0; skelidx <= MAX_SKEL_OBJECTS; skelidx++)
	{
		if (!skelobjects[skelidx].inuse &&
			(!skelobjects[skelidx].numbones || skelobjects[skelidx].numbones == bonecount) &&
			(!skelobjects[skelidx].world || skelobjects[skelidx].world == prinst->parms->user))
		{
			if (!skelobjects[skelidx].numbones)
			{
				skelobjects[skelidx].numbones = bonecount;
				skelobjects[skelidx].bonematrix = (float*)PR_AddString(prinst, "", sizeof(float)*12*bonecount, false);
			}
			skelobjects[skelidx].world = prinst->parms->user;
			if (numskelobjectsused <= skelidx)
				numskelobjectsused = skelidx + 1;
			skelobjects[skelidx].model = NULL;
			skelobjects[skelidx].inuse = 1;
			return &skelobjects[skelidx];
		}
	}

	return NULL;
}
static skelobject_t *skel_get(pubprogfuncs_t *prinst, int skelidx)
{
	skelidx--;
	if ((unsigned int)skelidx >= numskelobjectsused)
		return NULL;
	if (skelobjects[skelidx].inuse != 1)
		return NULL;
	return &skelobjects[skelidx];
}

void skel_lookup(pubprogfuncs_t *prinst, int skelidx, framestate_t *out)
{
	skelobject_t *sko = skel_get(prinst, skelidx);
	if (sko && sko->inuse)
	{
		out->skeltype = sko->type;
		out->bonecount = sko->numbones;
		out->bonestate = sko->bonematrix;
	}
}

void QCBUILTIN PF_skel_mmap(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skelidx = G_FLOAT(OFS_PARM0);
	skelobject_t *sko = skel_get(prinst, skelidx);
	if (!sko || sko->world != prinst->parms->user)
		G_INT(OFS_RETURN) = 0;
	else
		G_INT(OFS_RETURN) = (char*)sko->bonematrix - prinst->stringtable;
}

#ifdef RAGDOLL
//may not poke the skeletal object bone data.
static void rag_uninstanciate(skelobject_t *sko)
{
	int i;
	if (!sko->doll)
		return;

	for (i = 0; i < sko->numbodies; i++)
	{
		World_ODE_RagDestroyBody(sko->world, &sko->body[i].odebody);
	}
	BZ_Free(sko->body);
	sko->body = NULL;
	sko->numbodies = 0;

	for (i = 0; i < sko->numjoints; i++)
	{
		World_ODE_RagDestroyJoint(sko->world, &sko->joint[i]);
	}
	BZ_Free(sko->joint);
	sko->joint = NULL;
	sko->numjoints = 0;

	sko->doll->uses--;
	sko->doll = NULL;
}
void rag_genbodymatrix(skelobject_t *sko, odebodyinfo_t *dollbody, float *emat, float *result)
{
	float *bmat;
	int bone = dollbody->bone;
	bmat = sko->bonematrix + bone*12;
	R_ConcatTransforms((void*)emat, (void*)bmat, (void*)result);

	if (dollbody->orient)
	{
		float peer[12];
		bone = dollbody->orientpeer;
		bmat = sko->bonematrix + bone*12;
		
		R_ConcatTransforms((void*)emat, (void*)bmat, (void*)peer);
	}

	//FIXME: handle biasing it to point away from the parent bone towards an orientation bone
}
qboolean rag_animate(skelobject_t *sko, doll_t *doll, float *emat)
{
	//drive the various animated bodies to their updated positions
	int i;
	for (i = 0; i < sko->numbodies; i++)
	{
		if (!doll->body[i].animate)
			continue;
		rag_genbodymatrix(sko, &doll->body[i], emat, sko->body[i].animmatrix);
	}
	return true;
}
qboolean rag_instanciate(skelobject_t *sko, doll_t *doll, float *emat, wedict_t *ent)
{
	int i;
	float *bmat;
	float bodymat[12], worldmat[12];
	vec3_t aaa2[3];
	int numbones;
	galiasbone_t *bones = Mod_GetBoneInfo(sko->model, &numbones);
	int bone;
	odebody_t *body1, *body2;
	odejointinfo_t *j;
	sko->numbodies = doll->numbodies;
	sko->body = BZ_Malloc(sizeof(*sko->body) * sko->numbodies);
	sko->doll = doll;
	doll->uses++;
	sko->numanimated = 0;
	for (i = 0; i < sko->numbodies; i++)
	{
		memset(&sko->body[i], 0, sizeof(sko->body[i]));

		sko->body[i].animstrength = doll->body[i].animate;
		if (sko->body[i].animstrength)
			sko->numanimated++;

		//spawn the body in the base pose, so we can add joints etc (also ignoring the entity matrix, we'll fix all that up later).
		if (1)
			Matrix3x4_Invert_Simple(bones[doll->body[i].bone].inverse, bodymat);
		else
			rag_genbodymatrix(sko, &doll->body[i], emat, bodymat);
		if (!World_ODE_RagCreateBody(sko->world, &sko->body[i].odebody, &doll->body[i], bodymat, ent))
			return false;
	}
	sko->numjoints = doll->numjoints;
	sko->joint = BZ_Malloc(sizeof(*sko->joint) * sko->numjoints);
	memset(sko->joint, 0, sizeof(*sko->joint) * sko->numjoints);
	for(i = 0; i < sko->numjoints; i++)
	{
		j = &doll->joint[i];
		body1 = j->body1>=0?&sko->body[j->body1].odebody:NULL;
		body2 = j->body2>=0?&sko->body[j->body2].odebody:NULL;

		bone = j->bonepivot;
		bmat = sko->bonematrix + bone*12;

		if (1)
		{
			Matrix3x4_Invert_Simple(bones[j->bonepivot].inverse, worldmat);
		}
		else
		{
			memcpy(bodymat, bmat, sizeof(bodymat));
			bodymat[3] += j->offset[0];
			bodymat[3+4] += j->offset[1];
			bodymat[3+8] += j->offset[2];
			R_ConcatTransforms((void*)emat, (void*)bodymat, (void*)worldmat);
		}
		aaa2[0][0] = worldmat[3];
		aaa2[0][1] = worldmat[3+4];
		aaa2[0][2] = worldmat[3+8];
		VectorNormalize2(j->axis, aaa2[1]);
		VectorNormalize2(j->axis2, aaa2[2]);

		World_ODE_RagCreateJoint(sko->world, &sko->joint[i], j, body1, body2, aaa2);
	}

	//now the joints have all their various properties, move the bones to their real positions.
	//this might result in the body flying across the room...
	for (i = 0; i < sko->numbodies; i++)
	{
		rag_genbodymatrix(sko, &doll->body[i], emat, bodymat);
		World_ODE_RagMatrixToBody(&sko->body[i].odebody, bodymat);
	}

	sko->doll->numdefaultanimated = sko->numanimated;
	return true;
}

void CLQ1_AddOrientedCube(shader_t *shader, vec3_t mins, vec3_t maxs, float *matrix, float r, float g, float b, float a);
void CLQ1_AddOrientedCylinder(shader_t *shader, float radius, float height, qboolean capsule, float *matrix, float r, float g, float b, float a);
void CLQ1_DrawLine(shader_t *shader, vec3_t v1, vec3_t v2, float r, float g, float b, float a);
void rag_derive(skelobject_t *sko, skelobject_t *asko, float *emat)
{
	doll_t *doll = sko->doll;
	float *bmat = sko->bonematrix;
	float *amat = asko?asko->bonematrix:NULL;
	int numbones;
	galiasbone_t *bones = Mod_GetBoneInfo(sko->model, &numbones);
	int i;
	float invemat[12];
	float bodymat[12], rel[12];

	Matrix3x4_Invert(emat, invemat);

#ifndef SERVERONLY
	if (doll->drawn)
	{
		float rad;
		vec3_t mins, maxs;
		shader_t *debugshader = NULL;
		shader_t *lineshader = NULL;
		vec3_t start, end;
		for (i = 0; i < sko->numbodies; i++)
		{
			if (!doll->body[i].draw)
				continue;

			if (!debugshader)
				debugshader = R_RegisterShader("boneshader", SUF_NONE,
					"{\n"
					"polygonoffset\n"
					"{\n"
					"map $whiteimage\n"
					"blendfunc add\n"
					"rgbgen vertex\n"
					"alphagen vertex\n"
					"}\n"
					"}\n");
			
			World_ODE_RagMatrixFromBody(sko->world, &sko->body[i].odebody, bodymat);

			switch(doll->body[i].geomshape)
			{
			default:
			case GEOMTYPE_BOX:
				VectorScale(doll->body[i].dimensions, -0.5, mins);
				VectorScale(doll->body[i].dimensions, 0.5, maxs);
				CLQ1_AddOrientedCube(debugshader, mins, maxs, bodymat, 0.2, 0.2, 0.2, 1);
				break;
			case GEOMTYPE_CYLINDER:
				rad = (doll->body[i].dimensions[0] + doll->body[i].dimensions[1])*0.5;
				CLQ1_AddOrientedCylinder(debugshader, rad, doll->body[i].dimensions[2], false, bodymat, 0.2, 0.2, 0.2, 1);
				break;
			case GEOMTYPE_CAPSULE:
				rad = (doll->body[i].dimensions[0] + doll->body[i].dimensions[1])*0.5;
				CLQ1_AddOrientedCylinder(debugshader, rad, doll->body[i].dimensions[2], true, bodymat, 0.2, 0.2, 0.2, 1);
				break;
			case GEOMTYPE_SPHERE:
				rad = (doll->body[i].dimensions[0] + doll->body[i].dimensions[1] + doll->body[i].dimensions[2])/3;
				CLQ1_AddOrientedCylinder(debugshader, rad, rad, true, bodymat, 0.2, 0.2, 0.2, 1);
				break;
			}
		}
		mins[0] = mins[1] = mins[2] = -1;
		maxs[0] = maxs[1] = maxs[2] = 1;
		for (i = 0; i < doll->numjoints; i++)
		{
			if (!doll->joint[i].draw)
				continue;
			World_ODE_RagMatrixFromJoint(&sko->joint[i], &doll->joint[i], bodymat);
	//		CLQ1_AddOrientedCube(debugshader, mins, maxs, bodymat, 0, 0.2, 0, 1);

			if (!lineshader)
				lineshader = R_RegisterShader("lineshader", SUF_NONE,
					"{\n"
					"polygonoffset\n"
					"{\n"
					"map $whiteimage\n"
					"blendfunc add\n"
					"rgbgen vertex\n"
					"alphagen vertex\n"
					"}\n"
					"}\n");
			start[0] = bodymat[3];
			start[1] = bodymat[7];
			start[2] = bodymat[11];
			end[0] = bodymat[3] + bodymat[8]*4;
			end[1] = bodymat[7] + bodymat[9]*4;
			end[2] = bodymat[11] + bodymat[10]*4;
			CLQ1_DrawLine(lineshader, start, end, 0, 1, 1, 1);
			start[0] = bodymat[3] + bodymat[4]*-2;
			start[1] = bodymat[7] + bodymat[5]*-2;
			start[2] = bodymat[11] + bodymat[6]*-2;
			end[0] = bodymat[3] + bodymat[4]*2;
			end[1] = bodymat[7] + bodymat[5]*2;
			end[2] = bodymat[11] + bodymat[6]*2;
			CLQ1_DrawLine(lineshader, start, end, 1, 1, 0, 1);
		}
	}
#endif
	for (i = 0; i < doll->numbones; i++)
	{
		if (doll->bone[i].bodyidx >= 0)
		{
			//bones with a body are given an absolute pose matching that body.
			World_ODE_RagMatrixFromBody(sko->world, &sko->body[doll->bone[i].bodyidx].odebody, bodymat);
			//that body matrix is in world space, so transform to model space for our result
			R_ConcatTransforms((void*)invemat, (void*)bodymat, (void*)((float*)bmat+i*12));
		}
		else if (amat)	//FIXME: don't do this when the bone has an unanimated child body.
		{
			//this bone has no joint object, use the anim sko's relative pose info instead
			if (bones[i].parent >= 0)
				R_ConcatTransforms((void*)(bmat + bones[i].parent*12), (void*)((float*)amat+i*12), (void*)((float*)bmat+i*12));
			else
				memcpy((void*)((float*)bmat+i*12), (void*)((float*)amat+i*12), sizeof(float)*12);
		}
		else
		{
			//copy from the base pose
			Matrix3x4_Invert_Simple(bones[i].inverse, bodymat);
			//that's the absolute pose...
			if (bones[i].parent >= 0)
			{
				R_ConcatTransforms((void*)(bones[bones[i].parent].inverse), (void*)bodymat, (void*)rel);
				R_ConcatTransforms((void*)(bmat + bones[i].parent*12), (void*)rel, (void*)((float*)bmat+i*12));
			}
			else
			{
				//its all absolute when its the root.
				memcpy((void*)((float*)bmat+i*12), bodymat, sizeof(float)*12);
			}
		}
	}

	//if it wasn't before, it definitely is now.
	sko->type = SKEL_ABSOLUTE;
}

//called each physics frame to update the body velocities for animation
void rag_doallanimations(world_t *world)
{
	int i, j;
	doll_t *doll;
	skelobject_t *sko;
	for (i = 0; i < numskelobjectsused; i++)
	{
		sko = &skelobjects[i];
		if (sko->world != world)
			continue;
		doll = sko->doll;
		if (!doll || !sko->numanimated)
			continue;

		for (j = 0; j < sko->numbodies; j++)
		{
			if (!doll->body[j].animate)
				continue;
			World_ODE_RagMatrixToBody(&sko->body[j].odebody, sko->body[j].animmatrix);
		}
	}
}

#ifndef SERVERONLY
void rag_removedeltaent(lerpents_t *le)
{
	extern world_t csqc_world;
	int skelidx = le->skeletalobject;
	skelobject_t *skelobj;

	if (!skelidx)
		return;
	le->skeletalobject = 0;

	skelobj = skel_get(csqc_world.progs, skelidx);
	if (skelobj)
	{
		skelobj->inuse = 2;	//2 means don't reuse yet.
		skelobj->model = NULL;
		pendingkill = true;
	}
}

void rag_updatedeltaent(entity_t *ent, lerpents_t *le)
{
	extern world_t csqc_world;
	world_t *w;
	model_t *mod = ent->model;
	skelobject_t *sko;
	float emat[12];
	skelobject_t skorel = {0};
	float relmat[MAX_BONES*12];
	skorel.bonematrix = relmat;
	skorel.type = SKEL_RELATIVE;

	if (mod->dollinfo)
	{
		w = &csqc_world;
		if (!w->ode.ode)
			return;

		if (!le->skeletalobject)
		{
			sko = skel_create(w->progs, Mod_GetNumBones(mod, false));
			if (!sko)
				return;	//couldn't get one, ran out of memory or something?
			sko->model = mod;
			sko->type = SKEL_RELATIVE;
			le->skeletalobject = (sko - skelobjects) + 1;
		}
		else
		{
			sko = skel_get(w->progs, le->skeletalobject);
			if (!sko)
			{
				le->skeletalobject = 0;
				return;	//couldn't get one, ran out of memory or something?
			}
		}

		skorel.numbones = sko->numbones;

		//FIXME: provide some way for the animation to auto-trigger ragdoll (so framegroups can work automagically)
		if ((ent->framestate.g[FS_REG].frame[0] & 32767) || (ent->framestate.g[FS_REG].frame[1] & 32767))
			sko->numanimated = 0;
		else if (sko->doll)
			sko->numanimated = sko->doll->numdefaultanimated;
		Mod_GetBoneRelations(mod, 0, skorel.numbones, &ent->framestate, skorel.bonematrix);
		skorel.model = sko->model;
		if (sko->numanimated || sko->doll != mod->dollinfo)
		{
			skel_copy_toabs(sko, &skorel, 0, sko->numbones);
		}

		bonemat_fromaxisorg(emat, ent->axis, ent->origin);

		if (sko->doll != mod->dollinfo)
		{
			rag_uninstanciate(sko);
			rag_instanciate(sko, mod->dollinfo, emat, NULL);
		}
		if (sko->numanimated)
			rag_animate(sko, sko->doll, emat);

		rag_derive(sko, sko->numanimated?&skorel:NULL, emat);

		ent->framestate.bonestate = sko->bonematrix;
		ent->framestate.bonecount = sko->numbones;
		ent->framestate.skeltype = sko->type;
	}
}
#endif
#endif
#endif

#ifdef SKELETALOBJECTS
//update a skeletal object to track its ragdoll/apply a ragdoll to a skeletal object.
void QCBUILTIN PF_skel_ragedit(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	//do we want to be able to generate a ragdoll object with this function too?
#ifdef RAGDOLL
	wedict_t *wed = (wedict_t*)G_EDICT(prinst, OFS_PARM0);
	const char *ragname = PR_GetStringOfs(prinst, OFS_PARM1);
	int parentskel = G_FLOAT(OFS_PARM2);
	int skelidx;
	skelobject_t *sko, *psko;
	doll_t *doll;
	float emat[12];

	vec3_t d[3], a;
	//fixme: respond to renderflags&USEAXIS? scale?
	a[0] = wed->v->angles[0] * -1; /*mod_alias bug*/
	a[1] = wed->v->angles[1];
	a[2] = wed->v->angles[2];
	AngleVectors(a, d[0], d[1], d[2]);
	bonemat_fromqcvectors(emat, d[0], d[1], d[2], wed->v->origin);
	skelidx = wed->xv->skeletonindex;

	G_FLOAT(OFS_RETURN) = 0;

	//the parent skeletal object must be relative, if specified.
	psko = skel_get(prinst, parentskel);
	if (psko && psko->type != SKEL_RELATIVE)
		return;

	sko = skel_get(prinst, skelidx);
	if (!sko)
	{
		Con_DPrintf("PF_skel_ragedit: invalid skeletal object\n");
		return;
	}

	if (!sko->world->ode.ode)
	{
		Con_DPrintf("PF_skel_ragedit: ODE not enabled\n");
		return;
	}

	if (sko->doll)	//use the current doll
		doll = sko->doll;
	else if (sko->model) //
		doll = sko->model->dollinfo;
	else
		doll = NULL;

	if (*ragname)
	{
		char *cmd;

		ragname = Cmd_TokenizeString(ragname, false, false);
		cmd = Cmd_Argv(0);
		if (!stricmp(cmd, "enablejoint"))
		{
			int idx = rag_finddolljoint(sko->doll, Cmd_Argv(1));
			int enable = atoi(Cmd_Argv(2));
			World_ODE_RagEnableJoint(&sko->joint[idx], enable);
			G_FLOAT(OFS_RETURN) = 1;
			return;
		}
		else if (!stricmp(cmd, "animatebody"))
		{
			int body = rag_finddollbody(sko->doll, Cmd_Argv(1));
			float strength = atof(Cmd_Argv(2));
			if (body >= 0)
			{
				if (sko->body[body].animstrength)
					sko->numanimated--;
				sko->body[body].animstrength = strength;
				if (sko->body[body].animstrength)
					sko->numanimated++;
			}
			G_FLOAT(OFS_RETURN) = sko->numanimated;
			return;
		}
		else if (!stricmp(cmd, "animate"))
		{
			float strength = atof(Cmd_Argv(1));
			int i;
			sko->numanimated = 0;

			for (i = 0; i < sko->numbodies; i++)
			{
				sko->body[i].animstrength = sko->doll->body[i].animate * strength;
				if (sko->body[i].animstrength)
					sko->numanimated++;
			}

			if (sko->numanimated)
			{
				//make sure the animation target is valid.
				skel_copy_toabs(sko, psko?psko:sko, 0, sko->numbones);
				rag_animate(sko, sko->doll, emat);
			}
			G_FLOAT(OFS_RETURN) = 1;
			return;
		}
		else if (!stricmp(cmd, "doll"))
			doll = rag_loaddoll(sko->model, Cmd_Argv(1), sko->numbones);
		else if (!stricmp(cmd, "dollstring"))
			doll = rag_createdollfromstring(sko->model, "", sko->numbones, ragname);
		else if (!stricmp(cmd, "cleardoll"))
			doll = NULL;
		else
		{
			Con_Printf("PF_skel_ragedit: Unsupported command.\n");
			return;
		}
	}

	if (sko->doll != doll)
	{
		rag_uninstanciate(sko);
		if (!doll)
		{
			G_FLOAT(OFS_RETURN) = 1;	//technically success.
			return;
		}
		skel_copy_toabs(sko, psko?psko:sko, 0, sko->numbones);
		if (!rag_instanciate(sko, doll, emat, wed))
		{
			rag_uninstanciate(sko);
			Con_DPrintf("PF_skel_ragedit: unable to instanciate objects\n");
			G_FLOAT(OFS_RETURN) = 0;
			return;
		}
		if (sko->numanimated)
			rag_animate(sko, doll, emat);
	}
	else if (!doll)
	{
		G_FLOAT(OFS_RETURN) = 1;	//technically success.
		return;
	}
	else if (sko->numanimated)
	{
		skel_copy_toabs(sko, psko?psko:sko, 0, sko->numbones);
		rag_animate(sko, doll, emat);
	}

	rag_derive(sko, psko, emat);
	G_FLOAT(OFS_RETURN) = 1;
#endif
}

//float(float modelindex) skel_create (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_create (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;

	int numbones;
	skelobject_t *skelobj;
	model_t *model;
	int midx;
	int type;

	midx = G_FLOAT(OFS_PARM0);
	type = (prinst->callargc > 1)?G_FLOAT(OFS_PARM1):SKEL_RELATIVE;

	//default to failure
	G_FLOAT(OFS_RETURN) = 0;

	model = w->Get_CModel(w, midx);
	if (!model)
		return; //no model set, can't get a skeleton

	numbones = Mod_GetNumBones(model, type != SKEL_RELATIVE);
	if (!numbones)
	{
//		isabs = true;
//		numbones = Mod_GetNumBones(model, isabs);
//		if (!numbones)
			return;	//this isn't a skeletal model.
	}

	skelobj = skel_create(prinst, numbones);
	if (!skelobj)
		return;	//couldn't get one, ran out of memory or something?

	skelobj->model = model;
	skelobj->type = type;

	/*
	for (i = 0; i < numbones; i++)
	{
		galiasbone_t *bones = Mod_GetBoneInfo(skelobj->model);
		Matrix3x4_Invert_Simple(bones[i].inverse, skelobj->bonematrix + i*12);
	}
	skelobj->type = SKOT_ABSOLUTE;
	*/

	G_FLOAT(OFS_RETURN) = (skelobj - skelobjects) + 1;
}

//float(float skel, entity ent, float modelindex, float retainfrac, float firstbone, float lastbone) skel_build (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_build(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	int skelidx = G_FLOAT(OFS_PARM0);
	wedict_t *ent = (wedict_t*)G_EDICT(prinst, OFS_PARM1);
	int midx = G_FLOAT(OFS_PARM2);
	float retainfrac = G_FLOAT(OFS_PARM3);
	int firstbone = G_FLOAT(OFS_PARM4)-1;
	int lastbone = G_FLOAT(OFS_PARM5)-1;
	float addition = (prinst->callargc>6)?G_FLOAT(OFS_PARM6):1-retainfrac;

	int i, j;
	int numbones;
	framestate_t fstate;
	skelobject_t *skelobj;
	model_t *model;

	//default to failure
	G_FLOAT(OFS_RETURN) = 0;

	model = w->Get_CModel(w, midx);
	if (!model)
		return; //invalid model, can't get a skeleton

	w->Get_FrameState(w, ent, &fstate);

	//heh... don't copy.
	fstate.bonecount = 0;
	fstate.bonestate = NULL;

	numbones = Mod_GetNumBones(model, false);
	if (!numbones)
	{
		return;	//this isn't a skeletal model.
	}

	if (!skelidx)
		skelobj = skel_create(prinst, numbones);
	else
		skelobj = skel_get(prinst, skelidx);
	if (!skelobj)
		return;	//couldn't get one, ran out of memory or something?

	if (lastbone < 0)
		lastbone = numbones;
	if (lastbone > numbones)
		lastbone = numbones;
	if (firstbone < 0)
		firstbone = 0;
	if (lastbone < firstbone)
		lastbone = firstbone;

	if (skelobj->type != SKEL_RELATIVE)
	{
		if (firstbone > 0 || lastbone < skelobj->numbones || retainfrac)
		{
			Con_Printf("skel_build on non-relative skeleton\n");
			return;
		}
		skelobj->type = SKEL_RELATIVE;	//entire model will get replaced, convert it.
	}

	if (retainfrac == 0)
	{
		if (addition == 1) /*replace everything*/
			Mod_GetBoneRelations(model, firstbone, lastbone, &fstate, skelobj->bonematrix);
		else if (addition == 0) /*wipe it*/
			memset(skelobj->bonematrix + firstbone*12, 0, sizeof(float)*12*(lastbone-firstbone));
		else
		{
			//scale new
			float relationsbuf[MAX_BONES*12];
			Mod_GetBoneRelations(model, firstbone, lastbone, &fstate, relationsbuf);
			for (i = firstbone; i < lastbone; i++)
			{
				for (j = 0; j < 12; j++)
					skelobj->bonematrix[i*12+j] = addition*relationsbuf[i*12+j];
			}
		}
	}
	else
	{
		if (retainfrac != 1)
		{
			//rescale the existing bones
			for (i = firstbone; i < lastbone; i++)
			{
				for (j = 0; j < 12; j++)
					skelobj->bonematrix[i*12+j] *= retainfrac;
			}
		}
		if (addition == 1)
		{
			//just add
			float relationsbuf[MAX_BONES*12];
			Mod_GetBoneRelations(model, firstbone, lastbone, &fstate, relationsbuf);
			for (i = firstbone; i < lastbone; i++)
			{
				for (j = 0; j < 12; j++)
					skelobj->bonematrix[i*12+j] += relationsbuf[i*12+j];
			}
		}
		else if (addition)
		{
			//add+scale
			float relationsbuf[MAX_BONES*12];
			Mod_GetBoneRelations(model, firstbone, lastbone, &fstate, relationsbuf);
			for (i = firstbone; i < lastbone; i++)
			{
				for (j = 0; j < 12; j++)
					skelobj->bonematrix[i*12+j] += addition*relationsbuf[i*12+j];
			}
		}
	}

	G_FLOAT(OFS_RETURN) = (skelobj - skelobjects) + 1;
}

//float(float skel) skel_get_numbones (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_get_numbones (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skelidx = G_FLOAT(OFS_PARM0);
	skelobject_t *skelobj;

	skelobj = skel_get(prinst, skelidx);

	if (!skelobj)
		G_FLOAT(OFS_RETURN) = 0;
	else
		G_FLOAT(OFS_RETURN) = skelobj->numbones;
}

//string(float skel, float bonenum) skel_get_bonename (FTE_CSQC_SKELETONOBJECTS) (returns tempstring)
void QCBUILTIN PF_skel_get_bonename (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skelidx = G_FLOAT(OFS_PARM0);
	int boneidx = G_FLOAT(OFS_PARM1);
	skelobject_t *skelobj;

	skelobj = skel_get(prinst, skelidx);

	if (!skelobj)
		G_INT(OFS_RETURN) = 0;
	else
	{
		RETURN_TSTRING(Mod_GetBoneName(skelobj->model, boneidx));
	}
}

//float(float skel, float bonenum) skel_get_boneparent (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_get_boneparent (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skelidx = G_FLOAT(OFS_PARM0);
	int boneidx = G_FLOAT(OFS_PARM1);
	skelobject_t *skelobj;

	skelobj = skel_get(prinst, skelidx);

	if (!skelobj)
		G_FLOAT(OFS_RETURN) = 0;
	else
		G_FLOAT(OFS_RETURN) = Mod_GetBoneParent(skelobj->model, boneidx);
}

//float(float skel, string tagname) skel_find_bone (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_find_bone (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skelidx = G_FLOAT(OFS_PARM0);
	const char *bname = PR_GetStringOfs(prinst, OFS_PARM1);
	skelobject_t *skelobj;

	skelobj = skel_get(prinst, skelidx);
	if (!skelobj)
		G_FLOAT(OFS_RETURN) = 0;
	else
		G_FLOAT(OFS_RETURN) = Mod_TagNumForName(skelobj->model, bname);
}

//vector(float skel, float bonenum) skel_get_bonerel (FTE_CSQC_SKELETONOBJECTS) (sets v_forward etc)
void QCBUILTIN PF_skel_get_bonerel (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	int skelidx = G_FLOAT(OFS_PARM0);
	int boneidx = G_FLOAT(OFS_PARM1)-1;
	skelobject_t *skelobj = skel_get(prinst, skelidx);
	if (!skelobj || (unsigned int)boneidx >= skelobj->numbones)
		bonematident_toqcvectors(w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
	else if (skelobj->type!=SKEL_RELATIVE)
	{
		float tmp[12];
		float invparent[12];
		int parent;
		/*invert the parent, multiply that against the child, we now know the transform required to go from parent to child. woo.*/
		parent = Mod_GetBoneParent(skelobj->model, boneidx+1)-1;
		Matrix3x4_Invert(skelobj->bonematrix+12*parent, invparent);
		Matrix3x4_Multiply(invparent, skelobj->bonematrix+12*boneidx, tmp);
		bonemat_toqcvectors(tmp, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
	}
	else
		bonemat_toqcvectors(skelobj->bonematrix+12*boneidx, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
}

//vector(float skel, float bonenum) skel_get_boneabs (FTE_CSQC_SKELETONOBJECTS) (sets v_forward etc)
void QCBUILTIN PF_skel_get_boneabs (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	int skelidx = G_FLOAT(OFS_PARM0);
	int boneidx = G_FLOAT(OFS_PARM1)-1;
	float workingm[12], tempmatrix[3][4];
	int i;
	skelobject_t *skelobj = skel_get(prinst, skelidx);

	if (!skelobj || (unsigned int)boneidx >= skelobj->numbones)
		bonematident_toqcvectors(w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
	else if (skelobj->type != SKEL_RELATIVE)
	{
		//can just copy it out
		bonemat_toqcvectors(skelobj->bonematrix + boneidx*12, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
	}
	else
	{
		//we need to work out the abs position

		//testme

		//set up an identity matrix
		for (i = 0;i < 12;i++)
			workingm[i] = 0;
		workingm[0] = 1;
		workingm[5] = 1;
		workingm[10] = 1;

		while(boneidx >= 0)
		{
			//copy out the previous working matrix, so we don't stomp on it
			memcpy(tempmatrix, workingm, sizeof(tempmatrix));
			R_ConcatTransforms((void*)(skelobj->bonematrix + boneidx*12), (void*)tempmatrix, (void*)workingm);

			boneidx = Mod_GetBoneParent(skelobj->model, boneidx+1)-1;
		}
		bonemat_toqcvectors(workingm, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
	}
}

//void(entity ent, float bonenum, vector org, optional fwd, right, up) skel_set_bone_world (FTE_CSQC_SKELETONOBJECTS2) (reads v_forward etc)
void QCBUILTIN PF_skel_set_bone_world (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	wedict_t *ent = G_WEDICT(prinst, OFS_PARM0);
	unsigned int boneidx = G_FLOAT(OFS_PARM1)-1;
	float *matrix[3];
	skelobject_t *skelobj;
	float *bone;
	float childworld[12], parentinv[12];

	/*sort out the parameters*/
	if (prinst->callargc == 4)
	{
		vec3_t d[3], a;
		a[0] = G_VECTOR(OFS_PARM3)[0] * -1; /*mod_alias bug*/
		a[1] = G_VECTOR(OFS_PARM3)[1];
		a[2] = G_VECTOR(OFS_PARM3)[2];
		AngleVectors(a, d[0], d[1], d[2]);
		bonemat_fromqcvectors(childworld, d[0], d[1], d[2], G_VECTOR(OFS_PARM2));
	}
	else
	{
		if (prinst->callargc > 5)
		{
			matrix[0] = G_VECTOR(OFS_PARM3);
			matrix[1] = G_VECTOR(OFS_PARM4);
			matrix[2] = G_VECTOR(OFS_PARM5);
		}
		else
		{
			matrix[0] = w->g.v_forward;
			matrix[1] = w->g.v_right;
			matrix[2] = w->g.v_up;
		}
		bonemat_fromqcvectors(childworld, matrix[0], matrix[1], matrix[2], G_VECTOR(OFS_PARM2));
	}

	/*make sure the skeletal object is correct*/
	skelobj = skel_get(prinst, ent->xv->skeletonindex);
	if (!skelobj || boneidx >= skelobj->numbones)
		return;

	/*get the inverse of the parent matrix*/
	{
		float parentabs[12];
		float parentw[12];
		float parentent[12];
		framestate_t fstate;
		w->Get_FrameState(w, ent, &fstate);
		if (skelobj->type == SKEL_ABSOLUTE || !Mod_GetTag(skelobj->model, Mod_GetBoneParent(skelobj->model, boneidx+1), &fstate, parentabs))
		{
			bonemat_fromentity(w, ent, parentw);
		}
		else
		{
			bonemat_fromentity(w, ent, parentent);
			Matrix3x4_Multiply(parentabs, parentent, parentw);
		}
		Matrix3x4_Invert(parentw, parentinv);
	}

	/*calc the result*/
	bone = skelobj->bonematrix+12*boneidx;
	Matrix3x4_Multiply(childworld, parentinv, bone);
}

//void(float skel, float bonenum, vector org) skel_set_bone (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
void QCBUILTIN PF_skel_set_bone (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	int skelidx = G_FLOAT(OFS_PARM0);
	unsigned int boneidx = G_FLOAT(OFS_PARM1)-1;
	float *matrix[3];
	skelobject_t *skelobj;
	float *bone;

	if (prinst->callargc > 5)
	{
		matrix[0] = G_VECTOR(OFS_PARM3);
		matrix[1] = G_VECTOR(OFS_PARM4);
		matrix[2] = G_VECTOR(OFS_PARM5);
	}
	else
	{
		matrix[0] = w->g.v_forward;
		matrix[1] = w->g.v_right;
		matrix[2] = w->g.v_up;
	}

	skelobj = skel_get(prinst, skelidx);
	if (!skelobj || boneidx >= skelobj->numbones)
		return;

	bone = skelobj->bonematrix+12*boneidx;
	bonemat_fromqcvectors(bone, matrix[0], matrix[1], matrix[2], G_VECTOR(OFS_PARM2));
}

//void(float skel, float bonenum, vector org [, vector fwd, vector right, vector up]) skel_mul_bone (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
void QCBUILTIN PF_skel_mul_bone (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	int skelidx = G_FLOAT(OFS_PARM0);
	int boneidx = G_FLOAT(OFS_PARM1)-1;
	float temp[3][4];
	float mult[3][4];
	skelobject_t *skelobj;
	if (prinst->callargc > 5)
		bonemat_fromqcvectors((float*)mult, G_VECTOR(OFS_PARM3), G_VECTOR(OFS_PARM4), G_VECTOR(OFS_PARM5), G_VECTOR(OFS_PARM2));
	else
		bonemat_fromqcvectors((float*)mult, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_PARM2));

	skelobj = skel_get(prinst, skelidx);
	if (!skelobj || boneidx >= skelobj->numbones)
		return;
//testme
	Vector4Copy(skelobj->bonematrix+12*boneidx+0, temp[0]);
	Vector4Copy(skelobj->bonematrix+12*boneidx+4, temp[1]);
	Vector4Copy(skelobj->bonematrix+12*boneidx+8, temp[2]);
	R_ConcatTransforms(mult, temp, (float(*)[4])(skelobj->bonematrix+12*boneidx));
}

//void(float skel, float startbone, float endbone, vector org) skel_mul_bone (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
void QCBUILTIN PF_skel_mul_bones (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	int skelidx = G_FLOAT(OFS_PARM0);
	unsigned int startbone = G_FLOAT(OFS_PARM1)-1;
	unsigned int endbone = G_FLOAT(OFS_PARM2)-1;
	float temp[3][4];
	float mult[3][4];
	skelobject_t *skelobj;
	if (prinst->callargc > 6)
		bonemat_fromqcvectors((float*)mult, G_VECTOR(OFS_PARM4), G_VECTOR(OFS_PARM5), G_VECTOR(OFS_PARM6), G_VECTOR(OFS_PARM3));
	else
		bonemat_fromqcvectors((float*)mult, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_PARM3));

	skelobj = skel_get(prinst, skelidx);
	if (!skelobj)
		return;

	if (startbone == -1)
		startbone = 0;
	if (endbone == -1)
		endbone = skelobj->numbones;
	else if (endbone > skelobj->numbones)
		endbone = skelobj->numbones;

	while(startbone < endbone)
	{
		Vector4Copy(skelobj->bonematrix+12*startbone+0, temp[0]);
		Vector4Copy(skelobj->bonematrix+12*startbone+4, temp[1]);
		Vector4Copy(skelobj->bonematrix+12*startbone+8, temp[2]);
		R_ConcatTransforms(mult, temp, (float(*)[4])(skelobj->bonematrix+12*startbone));

		startbone++;
	}
}

//void(float skeldst, float skelsrc, float startbone, float entbone) skel_copybones (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_copybones (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skeldst = G_FLOAT(OFS_PARM0);
	int skelsrc = G_FLOAT(OFS_PARM1);
	int startbone = G_FLOAT(OFS_PARM2)-1;
	int endbone = G_FLOAT(OFS_PARM3)-1;

	skelobject_t *skelobjdst;
	skelobject_t *skelobjsrc;

	skelobjdst = skel_get(prinst, skeldst);
	skelobjsrc = skel_get(prinst, skelsrc);
	if (!skelobjdst || !skelobjsrc)
		return;
	if (startbone == -1)
		startbone = 0;
	if (endbone == -1)
		endbone = skelobjdst->numbones;
	if (endbone > skelobjdst->numbones)
		endbone = skelobjdst->numbones;
	if (endbone > skelobjsrc->numbones)
		endbone = skelobjsrc->numbones;

	if (skelobjsrc->type == skelobjdst->type)
	{
		while(startbone < endbone)
		{
			Vector4Copy(skelobjsrc->bonematrix+12*startbone+0, skelobjdst->bonematrix+12*startbone+0);
			Vector4Copy(skelobjsrc->bonematrix+12*startbone+4, skelobjdst->bonematrix+12*startbone+4);
			Vector4Copy(skelobjsrc->bonematrix+12*startbone+8, skelobjdst->bonematrix+12*startbone+8);

			startbone++;
		}
	}
	else if (skelobjsrc->type == SKEL_RELATIVE && skelobjdst->type == SKEL_ABSOLUTE)
	{
		/*copy from relative to absolute*/
		skel_copy_toabs(skelobjdst, skelobjsrc, startbone, endbone);
	}
	else
	{
		/*copy from absolute to relative*/
		//FIXME
	}
}

//void(float skel) skel_delete (FTE_CSQC_SKELETONOBJECTS)
void QCBUILTIN PF_skel_delete (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	int skelidx = G_FLOAT(OFS_PARM0);
	skelobject_t *skelobj;

	skelobj = skel_get(prinst, skelidx);
	if (skelobj)
	{
		skelobj->inuse = 2;	//2 means don't reuse yet.
		skelobj->model = NULL;
		pendingkill = true;
	}
}

//vector(entity ent, float tag) gettaginfo (DP_MD3_TAGSINFO)
void QCBUILTIN PF_gettaginfo (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	wedict_t *ent = G_WEDICT(prinst, OFS_PARM0);
	int tagnum = G_FLOAT(OFS_PARM1);

	int modelindex = ent->v->modelindex;

	model_t *mod = w->Get_CModel(w, modelindex);

	float transent[12];
	float transforms[12];
	float result[12];

	framestate_t fstate;

	w->Get_FrameState(w, ent, &fstate);

	if (!Mod_GetTag(mod, tagnum, &fstate, transforms))
	{
		bonemat_fromidentity(transforms);
	}

	if (ent->xv->tag_entity)
	{
#ifdef warningmsg
		#pragma warningmsg("PF_gettaginfo: This function doesn't honour attachments")
#endif
		Con_Printf("bug: PF_gettaginfo doesn't support attachments\n");
	}

	bonemat_fromentity(w, ent, transent);
	R_ConcatTransforms((void*)transent, (void*)transforms, (void*)result);

	bonemat_toqcvectors(result, w->g.v_forward, w->g.v_right, w->g.v_up, G_VECTOR(OFS_RETURN));
}

//vector(entity ent, string tagname) gettagindex (DP_MD3_TAGSINFO)
void QCBUILTIN PF_gettagindex (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	wedict_t *ent = G_WEDICT(prinst, OFS_PARM0);
	const char *tagname = PR_GetStringOfs(prinst, OFS_PARM1);
	model_t *mod = *tagname?w->Get_CModel(w, ent->v->modelindex):NULL;
	if (mod)
		G_FLOAT(OFS_RETURN) = Mod_TagNumForName(mod, tagname);
	else
		G_FLOAT(OFS_RETURN) = 0;
}

const char *Mod_FrameNameForNum(model_t *model, int num);
const char *Mod_SkinNameForNum(model_t *model, int num);

//string(float modidx, float framenum) frametoname
void QCBUILTIN PF_frametoname (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	unsigned int modelindex = G_FLOAT(OFS_PARM0);
	unsigned int skinnum = G_FLOAT(OFS_PARM1);
	model_t *mod = w->Get_CModel(w, modelindex);
	const char *n = Mod_FrameNameForNum(mod, skinnum);

	if (n)
		RETURN_TSTRING(n);
	else
		G_INT(OFS_RETURN) = 0;	//null string (which is also empty in qc)
}

void QCBUILTIN PF_frameforname (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	unsigned int modelindex = G_FLOAT(OFS_PARM0);
	char *str = PF_VarString(prinst, 1, pr_globals);
	model_t *mod = w->Get_CModel(w, modelindex);

	if (mod)
		G_FLOAT(OFS_RETURN) = Mod_FrameNumForName(mod, str);
	else
		G_FLOAT(OFS_RETURN) = -1;
}
void QCBUILTIN PF_frameduration (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	unsigned int modelindex = G_FLOAT(OFS_PARM0);
	unsigned int framenum = G_FLOAT(OFS_PARM1);
	model_t *mod = w->Get_CModel(w, modelindex);

	if (mod)
		G_FLOAT(OFS_RETURN) = Mod_GetFrameDuration(mod, framenum);
	else
		G_FLOAT(OFS_RETURN) = 0;
}

//string(float modidx, float skinnum) skintoname
void QCBUILTIN PF_skintoname (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
	world_t *w = prinst->parms->user;
	unsigned int modelindex = G_FLOAT(OFS_PARM0);
	unsigned int skinnum = G_FLOAT(OFS_PARM1);
	model_t *mod = w->Get_CModel(w, modelindex);
	const char *n = Mod_SkinNameForNum(mod, skinnum);

	if (n)
		RETURN_TSTRING(n);
	else
		G_INT(OFS_RETURN) = 0;	//null string (which is also empty in qc)
}
void QCBUILTIN PF_skinforname (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
{
#ifndef SERVERONLY
	world_t *w = prinst->parms->user;
	unsigned int modelindex = G_FLOAT(OFS_PARM0);
	char *str = PF_VarString(prinst, 1, pr_globals);
	model_t *mod = w->Get_CModel(w, modelindex);

	if (mod)
		G_FLOAT(OFS_RETURN) = Mod_SkinNumForName(mod, str);
	else
#endif
		G_FLOAT(OFS_RETURN) = -1;
}
#endif