DOOM-3-BFG

Anim_Blend.cpp (123962B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code 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 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #pragma hdrstop
 #include "../../idlib/precompiled.h"
 
 
 #include "../Game_local.h"
 
 static const char *channelNames[ ANIM_NumAnimChannels ] = {
 	"all", "torso", "legs", "head", "eyelids"
 };
 
 /***********************************************************************
 
 	idAnim
 
 ***********************************************************************/
 
 /*
 =====================
 idAnim::idAnim
 =====================
 */
 idAnim::idAnim() {
 	modelDef = NULL;
 	numAnims = 0;
 	memset( anims, 0, sizeof( anims ) );
 	memset( &flags, 0, sizeof( flags ) );
 }
 
 /*
 =====================
 idAnim::idAnim
 =====================
 */
 idAnim::idAnim( const idDeclModelDef *modelDef, const idAnim *anim ) {
 	int i;
 
 	this->modelDef = modelDef;
 	numAnims = anim->numAnims;
 	name = anim->name;
 	realname = anim->realname;
 	flags = anim->flags;
 
 	memset( anims, 0, sizeof( anims ) );
 	for( i = 0; i < numAnims; i++ ) {
 		anims[ i ] = anim->anims[ i ];
 		anims[ i ]->IncreaseRefs();
 	}
 
 	frameLookup.SetNum( anim->frameLookup.Num() );
 	memcpy( frameLookup.Ptr(), anim->frameLookup.Ptr(), frameLookup.MemoryUsed() );
 
 	frameCommands.SetNum( anim->frameCommands.Num() );
 	for( i = 0; i < frameCommands.Num(); i++ ) {
 		frameCommands[ i ] = anim->frameCommands[ i ];
 		if ( anim->frameCommands[ i ].string ) {
 			frameCommands[ i ].string = new (TAG_ANIM) idStr( *anim->frameCommands[ i ].string );
 		}
 	}
 }
 
 /*
 =====================
 idAnim::~idAnim
 =====================
 */
 idAnim::~idAnim() {
 	int i;
 
 	for( i = 0; i < numAnims; i++ ) {
 		anims[ i ]->DecreaseRefs();
 	}
 
 	for( i = 0; i < frameCommands.Num(); i++ ) {
 		delete frameCommands[ i ].string;
 	}
 }
 
 /*
 =====================
 idAnim::SetAnim
 =====================
 */
 void idAnim::SetAnim( const idDeclModelDef *modelDef, const char *sourcename, const char *animname, int num, const idMD5Anim *md5anims[ ANIM_MaxSyncedAnims ] ) {
 	int i;
 
 	this->modelDef = modelDef;
 
 	for( i = 0; i < numAnims; i++ ) {
 		anims[ i ]->DecreaseRefs();
 		anims[ i ] = NULL;
 	}
 
 	assert( ( num > 0 ) && ( num <= ANIM_MaxSyncedAnims ) );
 	numAnims	= num;
 	realname	= sourcename;
 	name		= animname;
 
 	for( i = 0; i < num; i++ ) {
 		anims[ i ] = md5anims[ i ];
 		anims[ i ]->IncreaseRefs();
 	}
 
 	memset( &flags, 0, sizeof( flags ) );
 
 	for( i = 0; i < frameCommands.Num(); i++ ) {
 		delete frameCommands[ i ].string;
 	}
 
 	frameLookup.Clear();
 	frameCommands.Clear();
 }
 
 /*
 =====================
 idAnim::Name
 =====================
 */
 const char *idAnim::Name() const {
 	return name;
 }
 
 /*
 =====================
 idAnim::FullName
 =====================
 */
 const char *idAnim::FullName() const {
 	return realname;
 }
 
 /*
 =====================
 idAnim::MD5Anim
 
 index 0 will never be NULL.  Any anim >= NumAnims will return NULL.
 =====================
 */
 const idMD5Anim *idAnim::MD5Anim( int num ) const {
 	if ( anims[0] == NULL ) { 
 		return NULL;
 	}
 	return anims[ num ];
 }
 
 /*
 =====================
 idAnim::ModelDef
 =====================
 */
 const idDeclModelDef *idAnim::ModelDef() const {
 	return modelDef;
 }
 
 /*
 =====================
 idAnim::Length
 =====================
 */
 int idAnim::Length() const {
 	if ( !anims[ 0 ] ) {
 		return 0;
 	}
 
 	return anims[ 0 ]->Length();
 }
 
 /*
 =====================
 idAnim::NumFrames
 =====================
 */
 int	idAnim::NumFrames() const { 
 	if ( !anims[ 0 ] ) {
 		return 0;
 	}
 	
 	return anims[ 0 ]->NumFrames();
 }
 
 /*
 =====================
 idAnim::NumAnims
 =====================
 */
 int	idAnim::NumAnims() const { 
 	return numAnims;
 }
 
 /*
 =====================
 idAnim::TotalMovementDelta
 =====================
 */
 const idVec3 &idAnim::TotalMovementDelta() const {
 	if ( !anims[ 0 ] ) {
 		return vec3_zero;
 	}
 	
 	return anims[ 0 ]->TotalMovementDelta();
 }
 
 /*
 =====================
 idAnim::GetOrigin
 =====================
 */
 bool idAnim::GetOrigin( idVec3 &offset, int animNum, int currentTime, int cyclecount ) const {
 	if ( !anims[ animNum ] ) {
 		offset.Zero();
 		return false;
 	}
 
 	anims[ animNum ]->GetOrigin( offset, currentTime, cyclecount );
 	return true;
 }
 
 /*
 =====================
 idAnim::GetOriginRotation
 =====================
 */
 bool idAnim::GetOriginRotation( idQuat &rotation, int animNum, int currentTime, int cyclecount ) const {
 	if ( !anims[ animNum ] ) {
 		rotation.Set( 0.0f, 0.0f, 0.0f, 1.0f );
 		return false;
 	}
 
 	anims[ animNum ]->GetOriginRotation( rotation, currentTime, cyclecount );
 	return true;
 }
 
 /*
 =====================
 idAnim::GetBounds
 =====================
 */
 ID_INLINE bool idAnim::GetBounds( idBounds &bounds, int animNum, int currentTime, int cyclecount ) const {
 	if ( !anims[ animNum ] ) {
 		return false;
 	}
 
 	anims[ animNum ]->GetBounds( bounds, currentTime, cyclecount );
 	return true;
 }
 
 
 /*
 =====================
 idAnim::AddFrameCommand
 
 Returns NULL if no error.
 =====================
 */
 const char *idAnim::AddFrameCommand( const idDeclModelDef *modelDef, int framenum, idLexer &src, const idDict *def ) {
 	int					i;
 	int					index;
 	idStr				text;
 	idStr				funcname;
 	frameCommand_t		fc;
 	idToken				token;
 	const jointInfo_t	*jointInfo;
 
 	// make sure we're within bounds
 	if ( ( framenum < 1 ) || ( framenum > anims[ 0 ]->NumFrames() ) ) {
 		return va( "Frame %d out of range", framenum );
 	}
 
 	// frame numbers are 1 based in .def files, but 0 based internally
 	framenum--;
 
 	memset( &fc, 0, sizeof( fc ) );
 
 	if( !src.ReadTokenOnLine( &token ) ) {
 		return "Unexpected end of line";
 	}
 	if ( token == "call" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SCRIPTFUNCTION;
 		fc.function = gameLocal.program.FindFunction( token );
 		if ( !fc.function ) {
 			return va( "Function '%s' not found", token.c_str() );
 		}
 	} else if ( token == "object_call" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SCRIPTFUNCTIONOBJECT;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "event" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_EVENTFUNCTION;
 		const idEventDef *ev = idEventDef::FindEvent( token );
 		if ( !ev ) {
 			return va( "Event '%s' not found", token.c_str() );
 		}
 		if ( ev->GetNumArgs() != 0 ) {
 			return va( "Event '%s' has arguments", token.c_str() );
 		}
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "sound" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_voice" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_VOICE;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_voice2" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_VOICE2;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_body" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_BODY;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_body2" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_BODY2;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_body3" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_BODY3;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_weapon" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_WEAPON;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_global" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_GLOBAL;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_item" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_ITEM;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "sound_chatter" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SOUND_CHATTER;
 		if ( !token.Cmpn( "snd_", 4 ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		} else {
 			fc.soundShader = declManager->FindSound( token );
 			if ( fc.soundShader->GetState() == DS_DEFAULTED ) {
 				gameLocal.Warning( "Sound '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "skin" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_SKIN;
 		if ( token == "none" ) {
 			fc.skin = NULL;
 		} else {
 			fc.skin = declManager->FindSkin( token );
 			if ( !fc.skin ) {
 				return va( "Skin '%s' not found", token.c_str() );
 			}
 		}
 	} else if ( token == "fx" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_FX;
 		if ( !declManager->FindType( DECL_FX, token.c_str() ) ) {
 			return va( "fx '%s' not found", token.c_str() );
 		}
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "trigger" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_TRIGGER;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "triggerSmokeParticle" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_TRIGGER_SMOKE_PARTICLE;
 		if ( !declManager->FindType( DECL_PARTICLE, token.c_str() ) ) {
 			return va( "Particle '%s' not found", token.c_str() );
 		}
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "melee" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_MELEE;
 		if ( !gameLocal.FindEntityDef( token.c_str(), false ) ) {
 			return va( "Unknown entityDef '%s'", token.c_str() );
 		}
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "direct_damage" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_DIRECTDAMAGE;
 		if ( !gameLocal.FindEntityDef( token.c_str(), false ) ) {
 			return va( "Unknown entityDef '%s'", token.c_str() );
 		}
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "attack_begin" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_BEGINATTACK;
 		if ( !gameLocal.FindEntityDef( token.c_str(), false ) ) {
 			return va( "Unknown entityDef '%s'", token.c_str() );
 		}
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "attack_end" ) {
 		fc.type = FC_ENDATTACK;
 	} else if ( token == "muzzle_flash" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		if ( ( token != "" ) && !modelDef->FindJoint( token ) ) {
 			return va( "Joint '%s' not found", token.c_str() );
 		}
 		fc.type = FC_MUZZLEFLASH;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "create_missile" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		if ( !modelDef->FindJoint( token ) ) {
 			return va( "Joint '%s' not found", token.c_str() );
 		}
 		fc.type = FC_CREATEMISSILE;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "launch_missile" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		if ( !modelDef->FindJoint( token ) ) {
 			return va( "Joint '%s' not found", token.c_str() );
 		}
 		fc.type = FC_LAUNCHMISSILE;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "fire_missile_at_target" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		jointInfo = modelDef->FindJoint( token );
 		if ( !jointInfo ) {
 			return va( "Joint '%s' not found", token.c_str() );
 		}
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_FIREMISSILEATTARGET;
 		fc.string = new (TAG_ANIM) idStr( token );
 		fc.index = jointInfo->num;
 	} else if ( token == "launch_projectile" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		if ( !declManager->FindDeclWithoutParsing( DECL_ENTITYDEF, token, false ) ) {
 			return "Unknown projectile def";
 		}
 		fc.type = FC_LAUNCH_PROJECTILE;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "trigger_fx" ) {
 		
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		jointInfo = modelDef->FindJoint( token );
 		if ( !jointInfo ) {
 			return va( "Joint '%s' not found", token.c_str() );
 		}
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		if ( !declManager->FindType( DECL_FX, token, false ) ) {
 			return "Unknown FX def";
 		}
 
 		fc.type = FC_TRIGGER_FX;
 		fc.string = new (TAG_ANIM) idStr( token );
 		fc.index = jointInfo->num;
 
 	} else if ( token == "start_emitter" ) {
 
 		idStr str;
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		str = token + " ";
 
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		jointInfo = modelDef->FindJoint( token );
 		if ( !jointInfo ) {
 			return va( "Joint '%s' not found", token.c_str() );
 		}
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		if ( !declManager->FindType( DECL_PARTICLE, token.c_str() ) ) {
 			return va( "Particle '%s' not found", token.c_str() );
 		}
 		str += token;
 		fc.type = FC_START_EMITTER;
 		fc.string = new (TAG_ANIM) idStr( str );
 		fc.index = jointInfo->num;
 
 	} else if ( token == "stop_emitter" ) {
 
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_STOP_EMITTER;
 		fc.string = new (TAG_ANIM) idStr( token );
 	} else if ( token == "footstep" ) {
 		fc.type = FC_FOOTSTEP;
 	} else if ( token == "leftfoot" ) {
 		fc.type = FC_LEFTFOOT;
 	} else if ( token == "rightfoot" ) {
 		fc.type = FC_RIGHTFOOT;
 	} else if ( token == "enableEyeFocus" ) {
 		fc.type = FC_ENABLE_EYE_FOCUS;
 	} else if ( token == "disableEyeFocus" ) {
 		fc.type = FC_DISABLE_EYE_FOCUS;
 	} else if ( token == "disableGravity" ) {
 		fc.type = FC_DISABLE_GRAVITY;
 	} else if ( token == "enableGravity" ) {
 		fc.type = FC_ENABLE_GRAVITY;
 	} else if ( token == "jump" ) {
 		fc.type = FC_JUMP;
 	} else if ( token == "enableClip" ) {
 		fc.type = FC_ENABLE_CLIP;
 	} else if ( token == "disableClip" ) {
 		fc.type = FC_DISABLE_CLIP;
 	} else if ( token == "enableWalkIK" ) {
 		fc.type = FC_ENABLE_WALK_IK;
 	} else if ( token == "disableWalkIK" ) {
 		fc.type = FC_DISABLE_WALK_IK;
 	} else if ( token == "enableLegIK" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_ENABLE_LEG_IK;
 		fc.index = atoi( token );
 	} else if ( token == "disableLegIK" ) {
 		if( !src.ReadTokenOnLine( &token ) ) {
 			return "Unexpected end of line";
 		}
 		fc.type = FC_DISABLE_LEG_IK;
 		fc.index = atoi( token );
 	} else if ( token == "recordDemo" ) {
 		fc.type = FC_RECORDDEMO;
 		if( src.ReadTokenOnLine( &token ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		}
 	} else if ( token == "aviGame" ) {
 		fc.type = FC_AVIGAME;
 		if( src.ReadTokenOnLine( &token ) ) {
 			fc.string = new (TAG_ANIM) idStr( token );
 		}
 	} else {
 		return va( "Unknown command '%s'", token.c_str() );
 	}
 
 	// check if we've initialized the frame loopup table
 	if ( !frameLookup.Num() ) {
 		// we haven't, so allocate the table and initialize it
 		frameLookup.SetGranularity( 1 );
 		frameLookup.SetNum( anims[ 0 ]->NumFrames() );
 		for( i = 0; i < frameLookup.Num(); i++ ) {
 			frameLookup[ i ].num = 0;
 			frameLookup[ i ].firstCommand = 0;
 		}
 	}
 
 	// allocate space for a new command
 	frameCommands.Alloc();
 
 	// calculate the index of the new command
 	index = frameLookup[ framenum ].firstCommand + frameLookup[ framenum ].num;
 
 	// move all commands from our index onward up one to give us space for our new command
 	for( i = frameCommands.Num() - 1; i > index; i-- ) {
 		frameCommands[ i ] = frameCommands[ i - 1 ];
 	}
 
 	// fix the indices of any later frames to account for the inserted command
 	for( i = framenum + 1; i < frameLookup.Num(); i++ ) {
 		frameLookup[ i ].firstCommand++;
 	}
 
 	// store the new command 
 	frameCommands[ index ] = fc;
 
 	// increase the number of commands on this frame
 	frameLookup[ framenum ].num++;
 
 	// return with no error
 	return NULL;
 }
 
 /*
 =====================
 idAnim::CallFrameCommands
 =====================
 */
 void idAnim::CallFrameCommands( idEntity *ent, int from, int to ) const {
 	int index;
 	int end;
 	int frame;
 	int numframes;
 
 	numframes = anims[ 0 ]->NumFrames();
 
 	frame = from;
 	while( frame != to ) {
 		frame++;
 		if ( frame >= numframes ) {
 			frame = 0;
 		}
 
 		index = frameLookup[ frame ].firstCommand;
 		end = index + frameLookup[ frame ].num;
 		while( index < end ) {
 			const frameCommand_t &command = frameCommands[ index++ ];
 			switch( command.type ) {
 				case FC_SCRIPTFUNCTION: {
 					gameLocal.CallFrameCommand( ent, command.function );
 					break;
 				}
 				case FC_SCRIPTFUNCTIONOBJECT: {
 					gameLocal.CallObjectFrameCommand( ent, command.string->c_str() );
 					break;
 				}
 				case FC_EVENTFUNCTION: {
 					const idEventDef *ev = idEventDef::FindEvent( command.string->c_str() );
 					ent->ProcessEvent( ev );
 					break;
 				}
 				case FC_SOUND: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_ANY, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_ANY, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_VOICE: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_VOICE, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_voice' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_VOICE, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_VOICE2: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_VOICE2, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_voice2' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_VOICE2, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_BODY: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_BODY, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_body' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_BODY, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_BODY2: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_BODY2, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_body2' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_BODY2, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_BODY3: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_BODY3, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_body3' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_BODY3, 0, false, NULL );
 					}
 					break;
 									 }
 				case FC_SOUND_WEAPON: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_WEAPON, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_weapon' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_WEAPON, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_GLOBAL: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_ANY, SSF_GLOBAL, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_global' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_ANY, SSF_GLOBAL, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_ITEM: {
 					if ( !command.soundShader ) {
 						if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_ITEM, 0, false, NULL ) ) {
 							gameLocal.Warning( "Framecommand 'sound_item' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 								ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 						}
 					} else {
 						ent->StartSoundShader( command.soundShader, SND_CHANNEL_ITEM, 0, false, NULL );
 					}
 					break;
 				}
 				case FC_SOUND_CHATTER: {
 					if ( ent->CanPlayChatterSounds() ) {
 						if ( !command.soundShader ) {
 							if ( !ent->StartSound( command.string->c_str(), SND_CHANNEL_VOICE, 0, false, NULL ) ) {
 								gameLocal.Warning( "Framecommand 'sound_chatter' on entity '%s', anim '%s', frame %d: Could not find sound '%s'",
 									ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 							}
 						} else {
 							ent->StartSoundShader( command.soundShader, SND_CHANNEL_VOICE, 0, false, NULL );
 						}
 					}
 					break;
 				}
 				case FC_FX: {
 					idEntityFx::StartFx( command.string->c_str(), NULL, NULL, ent, true );
 					break;
 				}
 				case FC_SKIN: {
 					ent->SetSkin( command.skin );
 					break;
 				}
 				case FC_TRIGGER: {
 					idEntity *target;
 
 					target = gameLocal.FindEntity( command.string->c_str() );
 					if ( target ) {
 						SetTimeState ts(target->timeGroup);
 						target->Signal( SIG_TRIGGER );
 						target->ProcessEvent( &EV_Activate, ent );
 						target->TriggerGuis();
 					} else {
 						gameLocal.Warning( "Framecommand 'trigger' on entity '%s', anim '%s', frame %d: Could not find entity '%s'",
 							ent->name.c_str(), FullName(), frame + 1, command.string->c_str() );
 					}
 					break;
 				}
 				case FC_TRIGGER_SMOKE_PARTICLE: {
 					ent->ProcessEvent( &AI_TriggerParticles, command.string->c_str() );
 					break;
 				}
 				case FC_MELEE: {
 					ent->ProcessEvent( &AI_AttackMelee, command.string->c_str() );
 					break;
 				}
 				case FC_DIRECTDAMAGE: {
 					ent->ProcessEvent( &AI_DirectDamage, command.string->c_str() );
 					break;
 				}
 				case FC_BEGINATTACK: {
 					ent->ProcessEvent( &AI_BeginAttack, command.string->c_str() );
 					break;
 				}
 				case FC_ENDATTACK: {
 					ent->ProcessEvent( &AI_EndAttack );
 					break;
 				}
 				case FC_MUZZLEFLASH: {
 					ent->ProcessEvent( &AI_MuzzleFlash, command.string->c_str() );
 					break;
 				}
 				case FC_CREATEMISSILE: {
 					ent->ProcessEvent( &AI_CreateMissile, command.string->c_str() );
 					break;
 				}
 				case FC_LAUNCHMISSILE: {
 					ent->ProcessEvent( &AI_AttackMissile, command.string->c_str() );
 					break;
 				}
 				case FC_FIREMISSILEATTARGET: {
 					ent->ProcessEvent( &AI_FireMissileAtTarget, modelDef->GetJointName( command.index ), command.string->c_str() );
 					break;
 				}
 				case FC_LAUNCH_PROJECTILE: {
 					ent->ProcessEvent( &AI_LaunchProjectile, command.string->c_str() );
 					break;
 				}
 				case FC_TRIGGER_FX: {
 					ent->ProcessEvent( &AI_TriggerFX, modelDef->GetJointName( command.index ), command.string->c_str() );
 					break;
 				}
 				case FC_START_EMITTER: {
 					int index = command.string->Find(" ");
 					if(index >= 0) {
 						idStr name = command.string->Left(index);
 						idStr particle = command.string->Right(command.string->Length() - index - 1);
 						ent->ProcessEvent( &AI_StartEmitter, name.c_str(), modelDef->GetJointName( command.index ), particle.c_str() );
 					}
 				}
 
 				case FC_STOP_EMITTER: {
 					ent->ProcessEvent( &AI_StopEmitter, command.string->c_str() );
 				}
 				case FC_FOOTSTEP : {
 					ent->ProcessEvent( &EV_Footstep );
 					break;
 				}
 				case FC_LEFTFOOT: {
 					ent->ProcessEvent( &EV_FootstepLeft );
 					break;
 				}
 				case FC_RIGHTFOOT: {
 					ent->ProcessEvent( &EV_FootstepRight );
 					break;
 				}
 				case FC_ENABLE_EYE_FOCUS: {
 					ent->ProcessEvent( &AI_EnableEyeFocus );
 					break;
 				}
 				case FC_DISABLE_EYE_FOCUS: {
 					ent->ProcessEvent( &AI_DisableEyeFocus );
 					break;
 				}
 				case FC_DISABLE_GRAVITY: {
 					ent->ProcessEvent( &AI_DisableGravity );
 					break;
 				}
 				case FC_ENABLE_GRAVITY: {
 					ent->ProcessEvent( &AI_EnableGravity );
 					break;
 				}
 				case FC_JUMP: {
 					ent->ProcessEvent( &AI_JumpFrame );
 					break;
 				}
 				case FC_ENABLE_CLIP: {
 					ent->ProcessEvent( &AI_EnableClip );
 					break;
 				}
 				case FC_DISABLE_CLIP: {
 					ent->ProcessEvent( &AI_DisableClip );
 					break;
 				}
 				case FC_ENABLE_WALK_IK: {
 					ent->ProcessEvent( &EV_EnableWalkIK );
 					break;
 				}
 				case FC_DISABLE_WALK_IK: {
 					ent->ProcessEvent( &EV_DisableWalkIK );
 					break;
 				}
 				case FC_ENABLE_LEG_IK: {
 					ent->ProcessEvent( &EV_EnableLegIK, command.index );
 					break;
 				}
 				case FC_DISABLE_LEG_IK: {
 					ent->ProcessEvent( &EV_DisableLegIK, command.index );
 					break;
 				}
 				case FC_RECORDDEMO: {
 					if ( command.string ) {
 						cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "recordDemo %s", command.string->c_str() ) );
 					} else {
 						cmdSystem->BufferCommandText( CMD_EXEC_NOW, "stoprecording" );
 					}
 					break;
 				}
 				case FC_AVIGAME: {
 					if ( command.string ) {
 						cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "aviGame %s", command.string->c_str() ) );
 					} else {
 						cmdSystem->BufferCommandText( CMD_EXEC_NOW, "aviGame" );
 					}
 					break;
 				}
 			}
 		}
 	}
 }
 
 /*
 =====================
 idAnim::FindFrameForFrameCommand
 =====================
 */
 int	idAnim::FindFrameForFrameCommand( frameCommandType_t framecommand, const frameCommand_t **command ) const {
 	int frame;
 	int index;
 	int numframes;
 	int end;
 
 	if ( !frameCommands.Num() ) {
 		return -1;
 	}
 
 	numframes = anims[ 0 ]->NumFrames();
 	for( frame = 0; frame < numframes; frame++ ) {
 		end = frameLookup[ frame ].firstCommand + frameLookup[ frame ].num;
 		for( index = frameLookup[ frame ].firstCommand; index < end; index++ ) {
 			if ( frameCommands[ index ].type == framecommand ) {
 				if ( command ) {
 					*command = &frameCommands[ index ];
 				}
 				return frame;
 			}
 		}
 	}
 
 	if ( command ) {
 		*command = NULL;
 	}
 
 	return -1;
 }
 
 /*
 =====================
 idAnim::HasFrameCommands
 =====================
 */
 bool idAnim::HasFrameCommands() const {
 	if ( !frameCommands.Num() ) {
 		return false;
 	}
 	return true;
 }
 
 /*
 =====================
 idAnim::SetAnimFlags
 =====================
 */
 void idAnim::SetAnimFlags( const animFlags_t &animflags ) {
 	flags = animflags;
 }
 
 /*
 =====================
 idAnim::GetAnimFlags
 =====================
 */
 const animFlags_t &idAnim::GetAnimFlags() const {
 	return flags;
 }
 
 /***********************************************************************
 
 	idAnimBlend
 
 ***********************************************************************/
 
 /*
 =====================
 idAnimBlend::idAnimBlend
 =====================
 */
 idAnimBlend::idAnimBlend() {
 	Reset( NULL );
 }
 
 /*
 =====================
 idAnimBlend::Save
 
 archives object for save game file
 =====================
 */
 void idAnimBlend::Save( idSaveGame *savefile ) const {
 	int i;
 
 	savefile->WriteInt( starttime );
 	savefile->WriteInt( endtime );
 	savefile->WriteInt( timeOffset );
 	savefile->WriteFloat( rate );
 
 	savefile->WriteInt( blendStartTime );
 	savefile->WriteInt( blendDuration );
 	savefile->WriteFloat( blendStartValue );
 	savefile->WriteFloat( blendEndValue );
 
 	for( i = 0; i < ANIM_MaxSyncedAnims; i++ ) {
 		savefile->WriteFloat( animWeights[ i ] );
 	}
 	savefile->WriteShort( cycle );
 	savefile->WriteShort( frame );
 	savefile->WriteShort( animNum );
 	savefile->WriteBool( allowMove );
 	savefile->WriteBool( allowFrameCommands );
 }
 
 /*
 =====================
 idAnimBlend::Restore
 
 unarchives object from save game file
 =====================
 */
 void idAnimBlend::Restore( idRestoreGame *savefile, const idDeclModelDef *modelDef ) {
 	int	i;
 
 	this->modelDef = modelDef;
 
 	savefile->ReadInt( starttime );
 	savefile->ReadInt( endtime );
 	savefile->ReadInt( timeOffset );
 	savefile->ReadFloat( rate );
 
 	savefile->ReadInt( blendStartTime );
 	savefile->ReadInt( blendDuration );
 	savefile->ReadFloat( blendStartValue );
 	savefile->ReadFloat( blendEndValue );
 
 	for( i = 0; i < ANIM_MaxSyncedAnims; i++ ) {
 		savefile->ReadFloat( animWeights[ i ] );
 	}
 	savefile->ReadShort( cycle );
 	savefile->ReadShort( frame );
 	savefile->ReadShort( animNum );
 	if ( !modelDef ) {
 		animNum = 0;
 	} else if ( ( animNum < 0 ) || ( animNum > modelDef->NumAnims() ) ) {
 		gameLocal.Warning( "Anim number %d out of range for model '%s' during save game", animNum, modelDef->GetModelName() );
 		animNum = 0;
 	}
 	savefile->ReadBool( allowMove );
 	savefile->ReadBool( allowFrameCommands );
 }
 
 /*
 =====================
 idAnimBlend::Reset
 =====================
 */
 void idAnimBlend::Reset( const idDeclModelDef *_modelDef ) {
 	modelDef	= _modelDef;
 	cycle		= 1;
 	starttime	= 0;
 	endtime		= 0;
 	timeOffset	= 0;
 	rate		= 1.0f;
 	frame		= 0;
 	allowMove	= true;
 	allowFrameCommands = true;
 	animNum		= 0;
 
 	memset( animWeights, 0, sizeof( animWeights ) );
 
 	blendStartValue = 0.0f;
 	blendEndValue	= 0.0f;
     blendStartTime	= 0;
 	blendDuration	= 0;
 }
 
 /*
 =====================
 idAnimBlend::FullName
 =====================
 */
 const char *idAnimBlend::AnimFullName() const {
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return "";
 	}
 
 	return anim->FullName();
 }
 
 /*
 =====================
 idAnimBlend::AnimName
 =====================
 */
 const char *idAnimBlend::AnimName() const {
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return "";
 	}
 
 	return anim->Name();
 }
 
 /*
 =====================
 idAnimBlend::NumFrames
 =====================
 */
 int idAnimBlend::NumFrames() const {
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return 0;
 	}
 
 	return anim->NumFrames();
 }
 
 /*
 =====================
 idAnimBlend::Length
 =====================
 */
 int	idAnimBlend::Length() const {
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return 0;
 	}
 
 	return anim->Length();
 }
 
 /*
 =====================
 idAnimBlend::GetWeight
 =====================
 */
 float idAnimBlend::GetWeight( int currentTime ) const {
 	int		timeDelta;
 	float	frac;
 	float	w;
 
 	timeDelta = currentTime - blendStartTime;
 	if ( timeDelta <= 0 ) {
 		w = blendStartValue;
 	} else if ( timeDelta >= blendDuration ) {
 		w = blendEndValue;
 	} else {
 		frac = ( float )timeDelta / ( float )blendDuration;
 		w = blendStartValue + ( blendEndValue - blendStartValue ) * frac;
 	}
 
 	return w;
 }
 
 /*
 =====================
 idAnimBlend::GetFinalWeight
 =====================
 */
 float idAnimBlend::GetFinalWeight() const {
 	return blendEndValue;
 }
 
 /*
 =====================
 idAnimBlend::SetWeight
 =====================
 */
 void idAnimBlend::SetWeight( float newweight, int currentTime, int blendTime ) {
 	blendStartValue = GetWeight( currentTime );
 	blendEndValue = newweight;
     blendStartTime = currentTime - 1;
 	blendDuration = blendTime;
 
 	if ( !newweight ) {
 		endtime = currentTime + blendTime;
 	}
 }
 
 /*
 =====================
 idAnimBlend::NumSyncedAnims
 =====================
 */
 int idAnimBlend::NumSyncedAnims() const {
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return 0;
 	}
 
 	return anim->NumAnims();
 }
 
 /*
 =====================
 idAnimBlend::SetSyncedAnimWeight
 =====================
 */
 bool idAnimBlend::SetSyncedAnimWeight( int num, float weight ) {
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return false;
 	}
 
 	if ( ( num < 0 ) || ( num > anim->NumAnims() ) ) {
 		return false;
 	}
 
 	animWeights[ num ] = weight;
 	return true;
 }
 
 /*
 =====================
 idAnimBlend::SetFrame
 =====================
 */
 void idAnimBlend::SetFrame( const idDeclModelDef *modelDef, int _animNum, int _frame, int currentTime, int blendTime ) {
 	Reset( modelDef );
 	if ( !modelDef ) {
 		return;
 	}
 	
 	const idAnim *_anim = modelDef->GetAnim( _animNum );
 	if ( !_anim ) {
 		return;
 	}
 
 	const idMD5Anim *md5anim = _anim->MD5Anim( 0 );
 	if ( modelDef->Joints().Num() != md5anim->NumJoints() ) {
 		gameLocal.Warning( "Model '%s' has different # of joints than anim '%s'", modelDef->GetModelName(), md5anim->Name() );
 		return;
 	}
 	
 	animNum				= _animNum;
 	starttime			= currentTime;
 	endtime				= -1;
 	cycle				= -1;
 	animWeights[ 0 ]	= 1.0f;
 	frame				= _frame;
 
 	// a frame of 0 means it's not a single frame blend, so we set it to frame + 1
 	if ( frame <= 0 ) {
 		frame = 1;
 	} else if ( frame > _anim->NumFrames() ) {
 		frame = _anim->NumFrames();
 	}
 
 	// set up blend
 	blendEndValue		= 1.0f;
 	blendStartTime		= currentTime - 1;
 	blendDuration		= blendTime;
 	blendStartValue		= 0.0f;
 }
 
 /*
 =====================
 idAnimBlend::CycleAnim
 =====================
 */
 void idAnimBlend::CycleAnim( const idDeclModelDef *modelDef, int _animNum, int currentTime, int blendTime ) {
 	Reset( modelDef );
 	if ( !modelDef ) {
 		return;
 	}
 	
 	const idAnim *_anim = modelDef->GetAnim( _animNum );
 	if ( !_anim ) {
 		return;
 	}
 
 	const idMD5Anim *md5anim = _anim->MD5Anim( 0 );
 	if ( modelDef->Joints().Num() != md5anim->NumJoints() ) {
 		gameLocal.Warning( "Model '%s' has different # of joints than anim '%s'", modelDef->GetModelName(), md5anim->Name() );
 		return;
 	}
 
 	animNum				= _animNum;
 	animWeights[ 0 ]	= 1.0f;
 	endtime				= -1;
 	cycle				= -1;
 	if ( _anim->GetAnimFlags().random_cycle_start ) {
 		// start the animation at a random time so that characters don't walk in sync
 		starttime = currentTime - gameLocal.random.RandomFloat() * _anim->Length();
 	} else {
 		starttime = currentTime;
 	}
 
 	// set up blend
 	blendEndValue		= 1.0f;
 	blendStartTime		= currentTime - 1;
 	blendDuration		= blendTime;
 	blendStartValue		= 0.0f;
 }
 
 /*
 =====================
 idAnimBlend::PlayAnim
 =====================
 */
 void idAnimBlend::PlayAnim( const idDeclModelDef *modelDef, int _animNum, int currentTime, int blendTime ) {
 	Reset( modelDef );
 	if ( !modelDef ) {
 		return;
 	}
 	
 	const idAnim *_anim = modelDef->GetAnim( _animNum );
 	if ( !_anim ) {
 		return;
 	}
 
 	const idMD5Anim *md5anim = _anim->MD5Anim( 0 );
 	if ( modelDef->Joints().Num() != md5anim->NumJoints() ) {
 		gameLocal.Warning( "Model '%s' has different # of joints than anim '%s'", modelDef->GetModelName(), md5anim->Name() );
 		return;
 	}
 
 	animNum				= _animNum;
 	starttime			= currentTime;
 	endtime				= starttime + _anim->Length();
 	cycle				= 1;
 	animWeights[ 0 ]	= 1.0f;
 
 	// set up blend
 	blendEndValue		= 1.0f;
 	blendStartTime		= currentTime - 1;
 	blendDuration		= blendTime;
 	blendStartValue		= 0.0f;
 }
 
 /*
 =====================
 idAnimBlend::Clear
 =====================
 */
 void idAnimBlend::Clear( int currentTime, int clearTime ) {
 	if ( !clearTime ) {
 		Reset( modelDef );
 	} else {
 		SetWeight( 0.0f, currentTime, clearTime );
 	}
 }
 
 /*
 =====================
 idAnimBlend::IsDone
 =====================
 */
 bool idAnimBlend::IsDone( int currentTime ) const {
 	if ( !frame && ( endtime > 0 ) && ( currentTime >= endtime ) ) {
 		return true;
 	}
 
 	if ( ( blendEndValue <= 0.0f ) && ( currentTime >= ( blendStartTime + blendDuration ) ) ) {
 		return true;
 	}
 
 	return false;
 }
 
 /*
 =====================
 idAnimBlend::FrameHasChanged
 =====================
 */
 bool idAnimBlend::FrameHasChanged( int currentTime ) const {
 	// if we don't have an anim, no change
 	if ( !animNum ) {
 		return false;
 	}
 
 	// if anim is done playing, no change
 	if ( ( endtime > 0 ) && ( currentTime > endtime ) ) {
 		return false;
 	}
 
 	// if our blend weight changes, we need to update
 	if ( ( currentTime < ( blendStartTime + blendDuration ) && ( blendStartValue != blendEndValue ) ) ) {
 		return true;
 	}
 
 	// if we're a single frame anim and this isn't the frame we started on, we don't need to update
 	if ( ( frame || ( NumFrames() == 1 ) ) && ( currentTime != starttime ) ) {
 		return false;
 	}
 
 	return true;
 }
 
 /*
 =====================
 idAnimBlend::GetCycleCount
 =====================
 */
 int idAnimBlend::GetCycleCount() const {
 	return cycle;
 }
 
 /*
 =====================
 idAnimBlend::SetCycleCount
 =====================
 */
 void idAnimBlend::SetCycleCount( int count ) {
 	const idAnim *anim = Anim();
 
 	if ( !anim ) {
 		cycle = -1;
 		endtime = 0;
 	} else {
 		cycle = count;
 		if ( cycle < 0 ) {
 			cycle = -1;
 			endtime	= -1;
 		} else if ( cycle == 0 ) {
 			cycle = 1;
 
 			// most of the time we're running at the original frame rate, so avoid the int-to-float-to-int conversion
 			if ( rate == 1.0f ) {
 				endtime	= starttime - timeOffset + anim->Length();
 			} else if ( rate != 0.0f ) {
 				endtime	= starttime - timeOffset + anim->Length() / rate;
 			} else {
 				endtime = -1;
 			}
 		} else {
 			// most of the time we're running at the original frame rate, so avoid the int-to-float-to-int conversion
 			if ( rate == 1.0f ) {
 				endtime	= starttime - timeOffset + anim->Length() * cycle;
 			} else if ( rate != 0.0f ) {
 				endtime	= starttime - timeOffset + ( anim->Length() * cycle ) / rate;
 			} else {
 				endtime = -1;
 			}
 		}
 	}
 }
 
 /*
 =====================
 idAnimBlend::SetPlaybackRate
 =====================
 */
 void idAnimBlend::SetPlaybackRate( int currentTime, float newRate ) {
 	int animTime;
 
 	if ( rate == newRate ) {
 		return;
 	}
 
 	animTime = AnimTime( currentTime );
 	if ( newRate == 1.0f ) {
 		timeOffset = animTime - ( currentTime - starttime );
 	} else {
 		timeOffset = animTime - ( currentTime - starttime ) * newRate;
 	}
 
 	rate = newRate;
 
 	// update the anim endtime
 	SetCycleCount( cycle );
 }
 
 /*
 =====================
 idAnimBlend::GetPlaybackRate
 =====================
 */
 float idAnimBlend::GetPlaybackRate() const {
 	return rate;
 }
 
 /*
 =====================
 idAnimBlend::SetStartTime
 =====================
 */
 void idAnimBlend::SetStartTime( int _startTime ) {
 	starttime = _startTime;
 
 	// update the anim endtime
 	SetCycleCount( cycle );
 }
 
 /*
 =====================
 idAnimBlend::GetStartTime
 =====================
 */
 int idAnimBlend::GetStartTime() const {
 	if ( !animNum ) {
 		return 0;
 	}
 
 	return starttime;
 }
 
 /*
 =====================
 idAnimBlend::GetEndTime
 =====================
 */
 int idAnimBlend::GetEndTime() const {
 	if ( !animNum ) {
 		return 0;
 	}
 
 	return endtime;
 }
 
 /*
 =====================
 idAnimBlend::PlayLength
 =====================
 */
 int idAnimBlend::PlayLength() const {
 	if ( !animNum ) {
 		return 0;
 	}
 
 	if ( endtime < 0 ) {
 		return -1;
 	}
 
 	return endtime - starttime + timeOffset;
 }
 
 /*
 =====================
 idAnimBlend::AllowMovement
 =====================
 */
 void idAnimBlend::AllowMovement( bool allow ) {
 	allowMove = allow;
 }
 
 /*
 =====================
 idAnimBlend::AllowFrameCommands
 =====================
 */
 void idAnimBlend::AllowFrameCommands( bool allow ) {
 	allowFrameCommands = allow;
 }
 
 
 /*
 =====================
 idAnimBlend::Anim
 =====================
 */
 const idAnim *idAnimBlend::Anim() const {
 	if ( !modelDef ) {
 		return NULL;
 	}
 
 	const idAnim *anim = modelDef->GetAnim( animNum );
 	return anim;
 }
 
 /*
 =====================
 idAnimBlend::AnimNum
 =====================
 */
 int idAnimBlend::AnimNum() const {
 	return animNum;
 }
 
 /*
 =====================
 idAnimBlend::AnimTime
 =====================
 */
 int idAnimBlend::AnimTime( int currentTime ) const {
 	int time;
 	int length;
 	const idAnim *anim = Anim();
 
 	if ( anim ) {
 		if ( frame ) {
 			return FRAME2MS( frame - 1 );
 		}
 
 		// most of the time we're running at the original frame rate, so avoid the int-to-float-to-int conversion
 		if ( rate == 1.0f ) {
 			time = currentTime - starttime + timeOffset;
 		} else {
 			time = static_cast<int>( ( currentTime - starttime ) * rate ) + timeOffset;
 		}
 
 		// given enough time, we can easily wrap time around in our frame calculations, so
 		// keep cycling animations' time within the length of the anim.
 		length = anim->Length();
 		if ( ( cycle < 0 ) && ( length > 0 ) ) {
 			time %= length;
 
 			// time will wrap after 24 days (oh no!), resulting in negative results for the %.
 			// adding the length gives us the proper result.
 			if ( time < 0 ) {
 				time += length;
 			}
 		}
 		return time;
 	} else {
 		return 0;
 	}
 }
 
 /*
 =====================
 idAnimBlend::GetFrameNumber
 =====================
 */
 int idAnimBlend::GetFrameNumber( int currentTime ) const {
 	const idMD5Anim	*md5anim;
 	frameBlend_t	frameinfo;
 	int				animTime;
 
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return 1;
 	}
 
 	if ( frame ) {
 		return frame;
 	}
 
 	md5anim = anim->MD5Anim( 0 );
 	animTime = AnimTime( currentTime );
 	md5anim->ConvertTimeToFrame( animTime, cycle, frameinfo );
 
 	return frameinfo.frame1 + 1;
 }
 
 /*
 =====================
 idAnimBlend::CallFrameCommands
 =====================
 */
 void idAnimBlend::CallFrameCommands( idEntity *ent, int fromtime, int totime ) const {
 	const idMD5Anim	*md5anim;
 	frameBlend_t	frame1;
 	frameBlend_t	frame2;
 	int				fromFrameTime;
 	int				toFrameTime;
 
 	if ( !allowFrameCommands || !ent || frame || ( ( endtime > 0 ) && ( fromtime > endtime ) ) ) {
 		return;
 	}
 
 	const idAnim *anim = Anim();
 	if ( !anim || !anim->HasFrameCommands() ) {
 		return;
 	}
 
 	if ( totime <= starttime ) {
 		// don't play until next frame or we'll play commands twice.
 		// this happens on the player sometimes.
 		return;
 	}
 
 	fromFrameTime	= AnimTime( fromtime );
 	toFrameTime		= AnimTime( totime );
 	if ( toFrameTime < fromFrameTime ) {
 		toFrameTime += anim->Length();
 	}
 
 	md5anim = anim->MD5Anim( 0 );
 	md5anim->ConvertTimeToFrame( fromFrameTime, cycle, frame1 );
 	md5anim->ConvertTimeToFrame( toFrameTime, cycle, frame2 );
 
 	if ( fromFrameTime <= 0 ) {
 		// make sure first frame is called
 		anim->CallFrameCommands( ent, -1, frame2.frame1 );
 	} else {
 		anim->CallFrameCommands( ent, frame1.frame1, frame2.frame1 );
 	}
 }
 
 /*
 =====================
 idAnimBlend::BlendAnim
 =====================
 */
 bool idAnimBlend::BlendAnim( int currentTime, int channel, int numJoints, idJointQuat *blendFrame, float &blendWeight, bool removeOriginOffset, bool overrideBlend, bool printInfo ) const {
 	int				i;
 	float			lerp;
 	float			mixWeight;
 	const idMD5Anim	*md5anim;
 	idJointQuat		*ptr;
 	frameBlend_t	frametime = { 0 };
 	idJointQuat		*jointFrame;
 	idJointQuat		*mixFrame;
 	int				numAnims;
 	int				time;
 
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return false;
 	}
 
 	float weight = GetWeight( currentTime );
 	if ( blendWeight > 0.0f ) {
 		if ( ( endtime >= 0 ) && ( currentTime >= endtime ) ) {
 			return false;
 		}
 		if ( !weight ) {
 			return false;
 		}
 		if ( overrideBlend ) {
 			blendWeight = 1.0f - weight;
 		}
 	}
 
 	if ( ( channel == ANIMCHANNEL_ALL ) && !blendWeight ) {
 		// we don't need a temporary buffer, so just store it directly in the blend frame
 		jointFrame = blendFrame;
 	} else {
 		// allocate a temporary buffer to copy the joints from
 		jointFrame = ( idJointQuat * )_alloca16( numJoints * sizeof( *jointFrame ) );
 	}
 
 	time = AnimTime( currentTime );
 
 	numAnims = anim->NumAnims();
 	if ( numAnims == 1 ) {
 		md5anim = anim->MD5Anim( 0 );
 		if ( frame ) {
 			md5anim->GetSingleFrame( frame - 1, jointFrame, modelDef->GetChannelJoints( channel ), modelDef->NumJointsOnChannel( channel ) );
 		} else {
 			md5anim->ConvertTimeToFrame( time, cycle, frametime );
 			md5anim->GetInterpolatedFrame( frametime, jointFrame, modelDef->GetChannelJoints( channel ), modelDef->NumJointsOnChannel( channel ) );
 		}
 	} else {
 		//
 		// need to mix the multipoint anim together first
 		//
 		// allocate a temporary buffer to copy the joints to
 		mixFrame = ( idJointQuat * )_alloca16( numJoints * sizeof( *jointFrame ) );
 
 		if ( !frame ) {
 			anim->MD5Anim( 0 )->ConvertTimeToFrame( time, cycle, frametime );
 		}
 
 		ptr = jointFrame;
 		mixWeight = 0.0f;
 		for( i = 0; i < numAnims; i++ ) {
 			if ( animWeights[ i ] > 0.0f ) {
 				mixWeight += animWeights[ i ];
 				lerp = animWeights[ i ] / mixWeight;
 				md5anim = anim->MD5Anim( i );
 				if ( frame ) {
 					md5anim->GetSingleFrame( frame - 1, ptr, modelDef->GetChannelJoints( channel ), modelDef->NumJointsOnChannel( channel ) );
 				} else {
 					md5anim->GetInterpolatedFrame( frametime, ptr, modelDef->GetChannelJoints( channel ), modelDef->NumJointsOnChannel( channel ) );
 				}
 
 				// only blend after the first anim is mixed in
 				if ( ptr != jointFrame ) {
 					SIMDProcessor->BlendJoints( jointFrame, ptr, lerp, modelDef->GetChannelJoints( channel ), modelDef->NumJointsOnChannel( channel ) );
 				}
 
 				ptr = mixFrame;
 			}
 		}
 
 		if ( !mixWeight ) {
 			return false;
 		}
 	}
 
 	if ( removeOriginOffset ) {
 		if ( allowMove ) {
 #ifdef VELOCITY_MOVE
 			jointFrame[ 0 ].t.x = 0.0f;
 #else
 			jointFrame[ 0 ].t.Zero();
 #endif
 		}
 
 		if ( anim->GetAnimFlags().anim_turn ) {
 			jointFrame[ 0 ].q.Set( -0.70710677f, 0.0f, 0.0f, 0.70710677f );
 		}
 	}
 
 	if ( !blendWeight ) {
 		blendWeight = weight;
 		if ( channel != ANIMCHANNEL_ALL ) {
 			const int *index = modelDef->GetChannelJoints( channel );
 			const int num = modelDef->NumJointsOnChannel( channel );
 			for( i = 0; i < num; i++ ) {
 				int j = index[i];
 				blendFrame[j].t = jointFrame[j].t;
 				blendFrame[j].q = jointFrame[j].q;
 			}
 		}
     } else {
 		blendWeight += weight;
 		lerp = weight / blendWeight;
 		SIMDProcessor->BlendJoints( blendFrame, jointFrame, lerp, modelDef->GetChannelJoints( channel ), modelDef->NumJointsOnChannel( channel ) );
 	}
 
 	if ( printInfo ) {
 		if ( frame ) {
 			gameLocal.Printf( "  %s: '%s', %d, %.2f%%\n", channelNames[ channel ], anim->FullName(), frame, weight * 100.0f );
 		} else {
 			gameLocal.Printf( "  %s: '%s', %.3f, %.2f%%\n", channelNames[ channel ], anim->FullName(), ( float )frametime.frame1 + frametime.backlerp, weight * 100.0f );
 		}
 	}
 
 	return true;
 }
 
 /*
 =====================
 idAnimBlend::BlendOrigin
 =====================
 */
 void idAnimBlend::BlendOrigin( int currentTime, idVec3 &blendPos, float &blendWeight, bool removeOriginOffset ) const {
 	float	lerp;
 	idVec3	animpos;
 	idVec3	pos;
 	int		time;
 	int		num;
 	int		i;
 
 	if ( frame || ( ( endtime > 0 ) && ( currentTime > endtime ) ) ) {
 		return;
 	}
 
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return;
 	}
 
 	if ( allowMove && removeOriginOffset ) {
 		return;
 	}
 
 	float weight = GetWeight( currentTime );
 	if ( !weight ) {
 		return;
 	}
 
 	time = AnimTime( currentTime );
 
 	pos.Zero();
 	num = anim->NumAnims();
 	for( i = 0; i < num; i++ ) {
 		anim->GetOrigin( animpos, i, time, cycle );
 		pos += animpos * animWeights[ i ];
 	}
 
 	if ( !blendWeight ) {
 		blendPos = pos;
 		blendWeight = weight;
 	} else {
 		lerp = weight / ( blendWeight + weight );
 		blendPos += lerp * ( pos - blendPos );
 		blendWeight += weight;
 	}
 }
 
 /*
 =====================
 idAnimBlend::BlendDelta
 =====================
 */
 void idAnimBlend::BlendDelta( int fromtime, int totime, idVec3 &blendDelta, float &blendWeight ) const {
 	idVec3	pos1;
 	idVec3	pos2;
 	idVec3	animpos;
 	idVec3	delta;
 	int		time1;
 	int		time2;
 	float	lerp;
 	int		num;
 	int		i;
 	
 	if ( frame || !allowMove || ( ( endtime > 0 ) && ( fromtime > endtime ) ) ) {
 		return;
 	}
 
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return;
 	}
 
 	float weight = GetWeight( totime );
 	if ( !weight ) {
 		return;
 	}
 
 	time1 = AnimTime( fromtime );
 	time2 = AnimTime( totime );
 	if ( time2 < time1 ) {
 		time2 += anim->Length();
 	}
 
 	num = anim->NumAnims();
 
 	pos1.Zero();
 	pos2.Zero();
 	for( i = 0; i < num; i++ ) {
 		anim->GetOrigin( animpos, i, time1, cycle );
 		pos1 += animpos * animWeights[ i ];
 
 		anim->GetOrigin( animpos, i, time2, cycle );
 		pos2 += animpos * animWeights[ i ];
 	}
 
 	delta = pos2 - pos1;
 	if ( !blendWeight ) {
 		blendDelta = delta;
 		blendWeight = weight;
 	} else {
 		lerp = weight / ( blendWeight + weight );
 		blendDelta += lerp * ( delta - blendDelta );
 		blendWeight += weight;
 	}
 }
 
 /*
 =====================
 idAnimBlend::BlendDeltaRotation
 =====================
 */
 void idAnimBlend::BlendDeltaRotation( int fromtime, int totime, idQuat &blendDelta, float &blendWeight ) const {
 	idQuat	q1;
 	idQuat	q2;
 	idQuat	q3;
 	int		time1;
 	int		time2;
 	float	lerp;
 	float	mixWeight;
 	int		num;
 	int		i;
 	
 	if ( frame || !allowMove || ( ( endtime > 0 ) && ( fromtime > endtime ) ) ) {
 		return;
 	}
 
 	const idAnim *anim = Anim();
 	if ( !anim || !anim->GetAnimFlags().anim_turn ) {
 		return;
 	}
 
 	float weight = GetWeight( totime );
 	if ( !weight ) {
 		return;
 	}
 
 	time1 = AnimTime( fromtime );
 	time2 = AnimTime( totime );
 	if ( time2 < time1 ) {
 		time2 += anim->Length();
 	}
 
 	q1.Set( 0.0f, 0.0f, 0.0f, 1.0f );
 	q2.Set( 0.0f, 0.0f, 0.0f, 1.0f );
 
 	mixWeight = 0.0f;
 	num = anim->NumAnims();
 	for( i = 0; i < num; i++ ) {
 		if ( animWeights[ i ] > 0.0f ) {
 			mixWeight += animWeights[ i ];
 			if ( animWeights[ i ] == mixWeight ) {
 				anim->GetOriginRotation( q1, i, time1, cycle );
 				anim->GetOriginRotation( q2, i, time2, cycle );
 			} else {
 				lerp = animWeights[ i ] / mixWeight;
 				anim->GetOriginRotation( q3, i, time1, cycle );
 				q1.Slerp( q1, q3, lerp );
 
 				anim->GetOriginRotation( q3, i, time2, cycle );
 				q2.Slerp( q1, q3, lerp );
 			}
 		}
 	}
 
 	q3 = q1.Inverse() * q2;
 	if ( !blendWeight ) {
 		blendDelta = q3;
 		blendWeight = weight;
 	} else {
 		lerp = weight / ( blendWeight + weight );
 		blendDelta.Slerp( blendDelta, q3, lerp );
 		blendWeight += weight;
 	}
 }
 
 /*
 =====================
 idAnimBlend::AddBounds
 =====================
 */
 bool idAnimBlend::AddBounds( int currentTime, idBounds &bounds, bool removeOriginOffset ) const {
 	int			i;
 	int			num;
 	idBounds	b;
 	int			time;
 	idVec3		pos;
 	bool		addorigin;
 
 	if ( ( endtime > 0 ) && ( currentTime > endtime ) ) {
 		return false;
 	}
 
 	const idAnim *anim = Anim();
 	if ( !anim ) {
 		return false;
 	}
 
 	float weight = GetWeight( currentTime );
 	if ( !weight ) {
 		return false;
 	}
 
 	time = AnimTime( currentTime );
 	num = anim->NumAnims();
 	
 	addorigin = !allowMove || !removeOriginOffset;
 	for( i = 0; i < num; i++ ) {
 		if ( anim->GetBounds( b, i, time, cycle ) ) {
 			if ( addorigin ) {
 				anim->GetOrigin( pos, i, time, cycle );
 				b.TranslateSelf( pos );
 			}
 			bounds.AddBounds( b );
 		}
 	}
 
 	return true;
 }
 
 /***********************************************************************
 
 	idDeclModelDef
 
 ***********************************************************************/
 
 /*
 =====================
 idDeclModelDef::idDeclModelDef
 =====================
 */
 idDeclModelDef::idDeclModelDef() {
 	modelHandle	= NULL;
 	skin		= NULL;
 	offset.Zero();
 	for ( int i = 0; i < ANIM_NumAnimChannels; i++ ) {
 		channelJoints[i].Clear();
 	}
 }
 
 /*
 =====================
 idDeclModelDef::~idDeclModelDef
 =====================
 */
 idDeclModelDef::~idDeclModelDef() {
 	FreeData();
 }
 
 /*
 =================
 idDeclModelDef::Size
 =================
 */
 size_t idDeclModelDef::Size() const {
 	return sizeof( idDeclModelDef );
 }
 
 /*
 =====================
 idDeclModelDef::CopyDecl
 =====================
 */
 void idDeclModelDef::CopyDecl( const idDeclModelDef *decl ) {
 	int i;
 
 	FreeData();
 
 	offset = decl->offset;
 	modelHandle = decl->modelHandle;
 	skin = decl->skin;
 
 	anims.SetNum( decl->anims.Num() );
 	for( i = 0; i < anims.Num(); i++ ) {
 		anims[ i ] = new (TAG_ANIM) idAnim( this, decl->anims[ i ] );
 	}
 
 	joints.SetNum( decl->joints.Num() );
 	memcpy( joints.Ptr(), decl->joints.Ptr(), decl->joints.Num() * sizeof( joints[0] ) );
 	jointParents.SetNum( decl->jointParents.Num() );
 	memcpy( jointParents.Ptr(), decl->jointParents.Ptr(), decl->jointParents.Num() * sizeof( jointParents[0] ) );
 	for ( i = 0; i < ANIM_NumAnimChannels; i++ ) {
 		channelJoints[i] = decl->channelJoints[i];
 	}
 }
 
 /*
 =====================
 idDeclModelDef::FreeData
 =====================
 */
 void idDeclModelDef::FreeData() {
 	anims.DeleteContents( true );
 	joints.Clear();
 	jointParents.Clear();
 	modelHandle	= NULL;
 	skin = NULL;
 	offset.Zero();
 	for ( int i = 0; i < ANIM_NumAnimChannels; i++ ) {
 		channelJoints[i].Clear();
 	}
 }
 
 /*
 ================
 idDeclModelDef::DefaultDefinition
 ================
 */
 const char *idDeclModelDef::DefaultDefinition() const {
 	return "{ }";
 }
 
 /*
 ====================
 idDeclModelDef::FindJoint
 ====================
 */
 const jointInfo_t *idDeclModelDef::FindJoint( const char *name ) const {
 	int					i;
 	const idMD5Joint	*joint;
 
 	if ( !modelHandle ) {
 		return NULL;
 	}
 	
 	joint = modelHandle->GetJoints();
 	for( i = 0; i < joints.Num(); i++, joint++ ) {
 		if ( !joint->name.Icmp( name ) ) {
 			return &joints[ i ];
 		}
 	}
 
 	return NULL;
 }
 
 /*
 =====================
 idDeclModelDef::ModelHandle
 =====================
 */
 idRenderModel *idDeclModelDef::ModelHandle() const {
 	return ( idRenderModel * )modelHandle;
 }
 
 /*
 =====================
 idDeclModelDef::GetJointList
 =====================
 */
 void idDeclModelDef::GetJointList( const char *jointnames, idList<jointHandle_t> &jointList ) const {
 	const char			*pos;
 	idStr				jointname;
 	const jointInfo_t	*joint;
 	const jointInfo_t	*child;
 	int					i;
 	int					num;
 	bool				getChildren;
 	bool				subtract;
 
 	if ( !modelHandle ) {
 		return;
 	}
 
 	jointList.Clear();
 
 	num = modelHandle->NumJoints();
 
 	// scan through list of joints and add each to the joint list
 	pos = jointnames;
 	while( *pos ) {
 		// skip over whitespace
 		while( ( *pos != 0 ) && isspace( (unsigned char)*pos ) ) {
 			pos++;
 		}
 
 		if ( !*pos ) {
 			// no more names
 			break;
 		}
 
 		// copy joint name
 		jointname = "";
 
 		if ( *pos == '-' ) {
 			subtract = true;
 			pos++;
 		} else {
 			subtract = false;
 		}
 
 		if ( *pos == '*' ) {
 			getChildren = true;
 			pos++;
 		} else {
 			getChildren = false;
 		}
 
 		while( ( *pos != 0 ) && !isspace( (unsigned char)*pos ) ) {
 			jointname += *pos;
 			pos++;
 		}
 
 		joint = FindJoint( jointname );
 		if ( !joint ) {
 			gameLocal.Warning( "Unknown joint '%s' in '%s' for model '%s'", jointname.c_str(), jointnames, GetName() );
 			continue;
 		}
 
 		if ( !subtract ) {
 			jointList.AddUnique( joint->num );
 		} else {
 			jointList.Remove( joint->num );
 		}
 
 		if ( getChildren ) {
 			// include all joint's children
 			child = joint + 1;
 			for( i = joint->num + 1; i < num; i++, child++ ) {
 				// all children of the joint should follow it in the list.
 				// once we reach a joint without a parent or with a parent
 				// who is earlier in the list than the specified joint, then
 				// we've gone through all it's children.
 				if ( child->parentNum < joint->num ) {
 					break;
 				}
 
 				if ( !subtract ) {
 					jointList.AddUnique( child->num );
 				} else {
 					jointList.Remove( child->num );
 				}
 			}
 		}
 	}
 }
 
 /*
 =====================
 idDeclModelDef::Touch
 =====================
 */
 void idDeclModelDef::Touch() const {
 	if ( modelHandle ) {
 		renderModelManager->FindModel( modelHandle->Name() );
 	}
 }
 
 /*
 =====================
 idDeclModelDef::GetDefaultSkin
 =====================
 */
 const idDeclSkin *idDeclModelDef::GetDefaultSkin() const {
 	return skin;
 }
 
 /*
 =====================
 idDeclModelDef::GetDefaultPose
 =====================
 */
 const idJointQuat *idDeclModelDef::GetDefaultPose() const {
 	return modelHandle->GetDefaultPose();
 }
 
 /*
 =====================
 idDeclModelDef::SetupJoints
 =====================
 */
 void idDeclModelDef::SetupJoints( int *numJoints, idJointMat **jointList, idBounds &frameBounds, bool removeOriginOffset ) const {
 	int					num;
 	const idJointQuat	*pose;
 	idJointMat			*list;
 
 	if ( !modelHandle || modelHandle->IsDefaultModel() ) {
 		Mem_Free16( (*jointList) );
 		(*jointList) = NULL;
 		frameBounds.Clear();
 		return;
 	}
 
 	// get the number of joints
 	num = modelHandle->NumJoints();
 
 	if ( !num ) {
 		gameLocal.Error( "model '%s' has no joints", modelHandle->Name() );
 	}
 
 	// set up initial pose for model (with no pose, model is just a jumbled mess)
 	list = (idJointMat *) Mem_Alloc16( SIMD_ROUND_JOINTS( num ) * sizeof( list[0] ), TAG_JOINTMAT );
 	pose = GetDefaultPose();
 
 	// convert the joint quaternions to joint matrices
 	SIMDProcessor->ConvertJointQuatsToJointMats( list, pose, joints.Num() );
 
 	// check if we offset the model by the origin joint
 	if ( removeOriginOffset ) {
 #ifdef VELOCITY_MOVE
 		list[ 0 ].SetTranslation( idVec3( offset.x, offset.y + pose[0].t.y, offset.z + pose[0].t.z ) );
 #else
 		list[ 0 ].SetTranslation( offset );
 #endif
 	} else {
 		list[ 0 ].SetTranslation( pose[0].t + offset );
 	}
 
 	// transform the joint hierarchy
 	SIMDProcessor->TransformJoints( list, jointParents.Ptr(), 1, joints.Num() - 1 );
 
 	SIMD_INIT_LAST_JOINT( list, num );
 
 	*numJoints = num;
 	*jointList = list;
 
 	// get the bounds of the default pose
 	frameBounds = modelHandle->Bounds( NULL );
 }
 
 /*
 =====================
 idDeclModelDef::ParseAnim
 =====================
 */
 bool idDeclModelDef::ParseAnim( idLexer &src, int numDefaultAnims ) {
 	int				i;
 	int				len;
 	idAnim			*anim;
 	const idMD5Anim	*md5anims[ ANIM_MaxSyncedAnims ];
 	const idMD5Anim	*md5anim;
 	idStr			alias;
 	idToken			realname;
 	idToken			token;
 	int				numAnims;
 	animFlags_t		flags;
 
 	numAnims = 0;
 	memset( md5anims, 0, sizeof( md5anims ) );
 
 	if( !src.ReadToken( &realname ) ) {
 		src.Warning( "Unexpected end of file" );
 		MakeDefault();
 		return false;
 	}
 	alias = realname;
 
 	for( i = 0; i < anims.Num(); i++ ) {
 		if ( !strcmp( anims[ i ]->FullName(), realname ) ) {
 			break;
 		}
 	}
 
 	if ( ( i < anims.Num() ) && ( i >= numDefaultAnims ) ) {
 		src.Warning( "Duplicate anim '%s'", realname.c_str() );
 		MakeDefault();
 		return false;
 	}
 
 	if ( i < numDefaultAnims ) {
 		anim = anims[ i ];
 	} else {
 		// create the alias associated with this animation
 		anim = new (TAG_ANIM) idAnim();
 		anims.Append( anim );
 	}
 
 	// random anims end with a number.  find the numeric suffix of the animation.
 	len = alias.Length();
 	for( i = len - 1; i > 0; i-- ) {
 		if ( !isdigit( (unsigned char)alias[ i ] ) ) {
 			break;
 		}
 	}
 
 	// check for zero length name, or a purely numeric name
 	if ( i <= 0 ) {
 		src.Warning( "Invalid animation name '%s'", alias.c_str() );
 		MakeDefault();
 		return false;
 	}
 
 	// remove the numeric suffix
 	alias.CapLength( i + 1 );
 
 	// parse the anims from the string
 	do {
 		if( !src.ReadToken( &token ) ) {
 			src.Warning( "Unexpected end of file" );
 			MakeDefault();
 			return false;
 		}
 
 		// lookup the animation
 		md5anim = animationLib.GetAnim( token );
 		if ( !md5anim ) {
 			src.Warning( "Couldn't load anim '%s'", token.c_str() );
 			MakeDefault();
 			return false;
 		}
 
 		md5anim->CheckModelHierarchy( modelHandle );
 
 		if ( numAnims > 0 ) {
 			// make sure it's the same length as the other anims
 			if ( md5anim->Length() != md5anims[ 0 ]->Length() ) {
 				src.Warning( "Anim '%s' does not match length of anim '%s'", md5anim->Name(), md5anims[ 0 ]->Name() );
 				MakeDefault();
 				return false;
 			}
 		}
 
 		if ( numAnims >= ANIM_MaxSyncedAnims ) {
 			src.Warning( "Exceeded max synced anims (%d)", ANIM_MaxSyncedAnims );
 			MakeDefault();
 			return false;
 		}
 
 		// add it to our list
 		md5anims[ numAnims ] = md5anim;
 		numAnims++;
 	} while ( src.CheckTokenString( "," ) );
 
 	if ( !numAnims ) {
 		src.Warning( "No animation specified" );
 		MakeDefault();
 		return false;
 	}
 
 	anim->SetAnim( this, realname, alias, numAnims, md5anims );
 	memset( &flags, 0, sizeof( flags ) );
 
 	// parse any frame commands or animflags
 	if ( src.CheckTokenString( "{" ) ) {
 		while( 1 ) {
 			if( !src.ReadToken( &token ) ) {
 				src.Warning( "Unexpected end of file" );
 				MakeDefault();
 				return false;
 			}
 			if ( token == "}" ) {
 				break;
 			}else if ( token == "prevent_idle_override" ) {
 				flags.prevent_idle_override = true;
 			} else if ( token == "random_cycle_start" ) {
 				flags.random_cycle_start = true;
 			} else if ( token == "ai_no_turn" ) {
 				flags.ai_no_turn = true;
 			} else if ( token == "anim_turn" ) {
 				flags.anim_turn = true;
 			} else if ( token == "frame" ) {
 				// create a frame command
 				int			framenum;
 				const char	*err;
 
 				// make sure we don't have any line breaks while reading the frame command so the error line # will be correct
 				if ( !src.ReadTokenOnLine( &token ) ) {
 					src.Warning( "Missing frame # after 'frame'" );
 					MakeDefault();
 					return false;
 				}
 				if ( token.type == TT_PUNCTUATION && token == "-" ) {
 					src.Warning( "Invalid frame # after 'frame'" );
 					MakeDefault();
 					return false;
 				} else if ( token.type != TT_NUMBER || token.subtype == TT_FLOAT ) {
 					src.Error( "expected integer value, found '%s'", token.c_str() );
 				}
 
 				// get the frame number
 				framenum = token.GetIntValue();
 
 				// put the command on the specified frame of the animation
 				err = anim->AddFrameCommand( this, framenum, src, NULL );
 				if ( err ) {
 					src.Warning( "%s", err );
 					MakeDefault();
 					return false;
 				}
 			} else {
 				src.Warning( "Unknown command '%s'", token.c_str() );
 				MakeDefault();
 				return false;
 			}
 		}
 	}
 
 	// set the flags
 	anim->SetAnimFlags( flags );
 	return true;
 }
 
 /*
 ================
 idDeclModelDef::Parse
 ================
 */
 bool idDeclModelDef::Parse( const char *text, const int textLength, bool allowBinaryVersion ) {
 	int					i;
 	int					num;
 	idStr				filename;
 	idStr				extension;
 	const idMD5Joint	*md5joint;
 	const idMD5Joint	*md5joints;
 	idLexer				src;
 	idToken				token;
 	idToken				token2;
 	idStr				jointnames;
 	int					channel;
 	jointHandle_t		jointnum;
 	idList<jointHandle_t> jointList;
 	int					numDefaultAnims;
 
 	src.LoadMemory( text, textLength, GetFileName(), GetLineNum() );
 	src.SetFlags( DECL_LEXER_FLAGS );
 	src.SkipUntilString( "{" );
 
 	numDefaultAnims = 0;
 	while( 1 ) {
 		if ( !src.ReadToken( &token ) ) {
 			break;
 		}
 
 		if ( !token.Icmp( "}" ) ) {
 			break;
 		}
 
 		if ( token == "inherit" ) {
 			if( !src.ReadToken( &token2 ) ) {
 				src.Warning( "Unexpected end of file" );
 				MakeDefault();
 				return false;
 			}
 			
 			const idDeclModelDef *copy = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, token2, false ) );
 			if ( !copy ) {
 				common->Warning( "Unknown model definition '%s'", token2.c_str() );
 			} else if ( copy->GetState() == DS_DEFAULTED ) {
 				common->Warning( "inherited model definition '%s' defaulted", token2.c_str() );
 				MakeDefault();
 				return false;
 			} else {
 				CopyDecl( copy );
 				numDefaultAnims = anims.Num();
 			}
 		} else if ( token == "skin" ) {
 			if( !src.ReadToken( &token2 ) ) {
 				src.Warning( "Unexpected end of file" );
 				MakeDefault();
 				return false;
 			}
 			skin = declManager->FindSkin( token2 );
 			if ( !skin ) {
 				src.Warning( "Skin '%s' not found", token2.c_str() );
 				MakeDefault();
 				return false;
 			}
 		} else if ( token == "mesh" ) {
 			if( !src.ReadToken( &token2 ) ) {
 				src.Warning( "Unexpected end of file" );
 				MakeDefault();
 				return false;
 			}
 			filename = token2;
 			filename.ExtractFileExtension( extension );
 			if ( extension != MD5_MESH_EXT ) {
 				src.Warning( "Invalid model for MD5 mesh" );
 				MakeDefault();
 				return false;
 			}
 			modelHandle = renderModelManager->FindModel( filename );
 			if ( !modelHandle ) {
 				src.Warning( "Model '%s' not found", filename.c_str() );
 				MakeDefault();
 				return false;
 			}
 
 			if ( modelHandle->IsDefaultModel() ) {
 				src.Warning( "Model '%s' defaulted", filename.c_str() );
 				MakeDefault();
 				return false;
 			}
 
 			// get the number of joints
 			num = modelHandle->NumJoints();
 			if ( !num ) {
 				src.Warning( "Model '%s' has no joints", filename.c_str() );
 			}
 
 			// set up the joint hierarchy
 			joints.SetGranularity( 1 );
 			joints.SetNum( num );
 			jointParents.SetNum( num );
 			channelJoints[0].SetNum( num );
 			md5joints = modelHandle->GetJoints();
 			md5joint = md5joints;
 			for( i = 0; i < num; i++, md5joint++ ) {
 				joints[i].channel = ANIMCHANNEL_ALL;
 				joints[i].num = static_cast<jointHandle_t>( i );
 				if ( md5joint->parent ) {
 					joints[i].parentNum = static_cast<jointHandle_t>( md5joint->parent - md5joints );
 				} else {
 					joints[i].parentNum = INVALID_JOINT;
 				}
 				jointParents[i] = joints[i].parentNum;
 				channelJoints[0][i] = i;
 			}
 		} else if ( token == "remove" ) {
 			// removes any anims whos name matches
 			if( !src.ReadToken( &token2 ) ) {
 				src.Warning( "Unexpected end of file" );
 				MakeDefault();
 				return false;
 			}
 			num = 0;
 			for( i = 0; i < anims.Num(); i++ ) {
 				if ( ( token2 == anims[ i ]->Name() ) || ( token2 == anims[ i ]->FullName() ) ) {
 					delete anims[ i ];
 					anims.RemoveIndex( i );
 					if ( i >= numDefaultAnims ) {
 						src.Warning( "Anim '%s' was not inherited.  Anim should be removed from the model def.", token2.c_str() );
 						MakeDefault();
 						return false;
 					}
 					i--;
 					numDefaultAnims--;
 					num++;
 					continue;
 				}
 			}
 			if ( !num ) {
 				src.Warning( "Couldn't find anim '%s' to remove", token2.c_str() );
 				MakeDefault();
 				return false;
 			}
 		} else if ( token == "anim" ) {
 			if ( !modelHandle ) {
 				src.Warning( "Must specify mesh before defining anims" );
 				MakeDefault();
 				return false;
 			}
 			if ( !ParseAnim( src, numDefaultAnims ) ) {
 				MakeDefault();
 				return false;
 			}
 		} else if ( token == "offset" ) {
 			if ( !src.Parse1DMatrix( 3, offset.ToFloatPtr() ) ) {
 				src.Warning( "Expected vector following 'offset'" );
 				MakeDefault();
 				return false;
 			}
 		} else if ( token == "channel" ) {
 			if ( !modelHandle ) {
 				src.Warning( "Must specify mesh before defining channels" );
 				MakeDefault();
 				return false;
 			}
 
 			// set the channel for a group of joints
 			if( !src.ReadToken( &token2 ) ) {
 				src.Warning( "Unexpected end of file" );
 				MakeDefault();
 				return false;
 			}
 			if ( !src.CheckTokenString( "(" ) ) {
 				src.Warning( "Expected { after '%s'\n", token2.c_str() );
 				MakeDefault();
 				return false;
 			}
 
 			for( i = ANIMCHANNEL_ALL + 1; i < ANIM_NumAnimChannels; i++ ) {
 				if ( !idStr::Icmp( channelNames[ i ], token2 ) ) {
 					break;
 				}
 			}
 
 			if ( i >= ANIM_NumAnimChannels ) {
 				src.Warning( "Unknown channel '%s'", token2.c_str() );
 				MakeDefault();
 				return false;
 			}
 
 			channel = i;
 			jointnames = "";
 
 			while( !src.CheckTokenString( ")" ) ) {
 				if( !src.ReadToken( &token2 ) ) {
 					src.Warning( "Unexpected end of file" );
 					MakeDefault();
 					return false;
 				}
 				jointnames += token2;
 				if ( ( token2 != "*" ) && ( token2 != "-" ) ) {
 					jointnames += " ";
 				}
 			}
 
 			GetJointList( jointnames, jointList );
 
 			channelJoints[ channel ].SetNum( jointList.Num() );
 			for( num = i = 0; i < jointList.Num(); i++ ) {
 				jointnum = jointList[ i ];
 				if ( joints[ jointnum ].channel != ANIMCHANNEL_ALL ) {
 					src.Warning( "Joint '%s' assigned to multiple channels", modelHandle->GetJointName( jointnum ) );
 					continue;
 				}
 				joints[ jointnum ].channel = channel;
 				channelJoints[ channel ][ num++ ] = jointnum;
 			}
 			channelJoints[ channel ].SetNum( num );
 		} else {
 			src.Warning( "unknown token '%s'", token.c_str() );
 			MakeDefault();
 			return false;
 		}
 	}
 
 	// shrink the anim list down to save space
 	anims.SetGranularity( 1 );
 	anims.SetNum( anims.Num() );
 
 	return true;
 }
 
 /*
 =====================
 idDeclModelDef::HasAnim
 =====================
 */
 bool idDeclModelDef::HasAnim( const char *name ) const {
 	int	i;
 
 	// find any animations with same name
 	for( i = 0; i < anims.Num(); i++ ) {
 		if ( !strcmp( anims[ i ]->Name(), name ) ) {
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 /*
 =====================
 idDeclModelDef::NumAnims
 =====================
 */
 int idDeclModelDef::NumAnims() const {
 	return anims.Num() + 1;
 }
 
 /*
 =====================
 idDeclModelDef::GetSpecificAnim
 
 Gets the exact anim for the name, without randomization.
 =====================
 */
 int idDeclModelDef::GetSpecificAnim( const char *name ) const {
 	int	i;
 
 	// find a specific animation
 	for( i = 0; i < anims.Num(); i++ ) {
 		if ( !strcmp( anims[ i ]->FullName(), name ) ) {
 			return i + 1;
 		}
 	}
 
 	// didn't find it
 	return 0;
 }
 
 /*
 =====================
 idDeclModelDef::GetAnim
 =====================
 */
 const idAnim *idDeclModelDef::GetAnim( int index ) const {
 	if ( ( index < 1 ) || ( index > anims.Num() ) ) {
 		return NULL;
 	}
 	
 	return anims[ index - 1 ];
 }
 
 /*
 =====================
 idDeclModelDef::GetAnim
 =====================
 */
 int idDeclModelDef::GetAnim( const char *name ) const {
 	int				i;
 	int				which;
 	const int		MAX_ANIMS = 64;
 	int				animList[ MAX_ANIMS ];
 	int				numAnims;
 	int				len;
 
 	len = strlen( name );
 	if ( len && idStr::CharIsNumeric( name[ len - 1 ] ) ) {
 		// find a specific animation
 		return GetSpecificAnim( name );
 	}
 
 	// find all animations with same name
 	numAnims = 0;
 	for( i = 0; i < anims.Num(); i++ ) {
 		if ( !strcmp( anims[ i ]->Name(), name ) ) {
 			animList[ numAnims++ ] = i;
 			if ( numAnims >= MAX_ANIMS ) {
 				break;
 			}
 		}
 	}
 
 	if ( !numAnims ) {
 		return 0;
 	}
 
 	// get a random anim
 	//FIXME: don't access gameLocal here?
 	which = gameLocal.random.RandomInt( numAnims );
 	return animList[ which ] + 1;
 }
 
 /*
 =====================
 idDeclModelDef::GetSkin
 =====================
 */
 const idDeclSkin *idDeclModelDef::GetSkin() const {
 	return skin;
 }
 
 /*
 =====================
 idDeclModelDef::GetModelName
 =====================
 */
 const char *idDeclModelDef::GetModelName() const {
 	if ( modelHandle ) {
 		return modelHandle->Name();
 	} else {
 		return "";
 	}
 }
 
 /*
 =====================
 idDeclModelDef::Joints
 =====================
 */
 const idList<jointInfo_t> &idDeclModelDef::Joints() const {
 	return joints;
 }
 
 /*
 =====================
 idDeclModelDef::JointParents
 =====================
 */
 const int * idDeclModelDef::JointParents() const {
 	return jointParents.Ptr();
 }
 
 /*
 =====================
 idDeclModelDef::NumJoints
 =====================
 */
 int idDeclModelDef::NumJoints() const {
 	return joints.Num();
 }
 
 /*
 =====================
 idDeclModelDef::GetJoint
 =====================
 */
 const jointInfo_t *idDeclModelDef::GetJoint( int jointHandle ) const {
 	if ( ( jointHandle < 0 ) || ( jointHandle > joints.Num() ) ) {
 		gameLocal.Error( "idDeclModelDef::GetJoint : joint handle out of range" );
 	}
 	return &joints[ jointHandle ];
 }
 
 /*
 ====================
 idDeclModelDef::GetJointName
 ====================
 */
 const char *idDeclModelDef::GetJointName( int jointHandle ) const {
 	const idMD5Joint *joint;
 
 	if ( !modelHandle ) {
 		return NULL;
 	}
 	
 	if ( ( jointHandle < 0 ) || ( jointHandle > joints.Num() ) ) {
 		gameLocal.Error( "idDeclModelDef::GetJointName : joint handle out of range" );
 	}
 
 	joint = modelHandle->GetJoints();
 	return joint[ jointHandle ].name.c_str();
 }
 
 /*
 =====================
 idDeclModelDef::NumJointsOnChannel
 =====================
 */
 int idDeclModelDef::NumJointsOnChannel( int channel ) const {
 	if ( ( channel < 0 ) || ( channel >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idDeclModelDef::NumJointsOnChannel : channel out of range" );
 		return 0;
 	}
 	return channelJoints[ channel ].Num();
 }
 
 /*
 =====================
 idDeclModelDef::GetChannelJoints
 =====================
 */
 const int * idDeclModelDef::GetChannelJoints( int channel ) const {
 	if ( ( channel < 0 ) || ( channel >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idDeclModelDef::GetChannelJoints : channel out of range" );
 		return NULL;
 	}
 	return channelJoints[ channel ].Ptr();
 }
 
 /*
 =====================
 idDeclModelDef::GetVisualOffset
 =====================
 */
 const idVec3 &idDeclModelDef::GetVisualOffset() const {
 	return offset;
 }
 
 /***********************************************************************
 
 	idAnimator
 
 ***********************************************************************/
 
 /*
 =====================
 idAnimator::idAnimator
 =====================
 */
 idAnimator::idAnimator() {
 	int	i, j;
 
 	modelDef				= NULL;
 	entity					= NULL;
 	numJoints				= 0;
 	joints					= NULL;
 	lastTransformTime		= -1;
 	stoppedAnimatingUpdate	= false;
 	removeOriginOffset		= false;
 	forceUpdate				= false;
 
 	frameBounds.Clear();
 
 	AFPoseJoints.SetGranularity( 1 );
 	AFPoseJointMods.SetGranularity( 1 );
 	AFPoseJointFrame.SetGranularity( 1 );
 
 	ClearAFPose();
 
 	for( i = ANIMCHANNEL_ALL; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++ ) {
 			channels[ i ][ j ].Reset( NULL );
 		}
 	}
 }
 
 /*
 =====================
 idAnimator::~idAnimator
 =====================
 */
 idAnimator::~idAnimator() {
 	FreeData();
 }
 
 /*
 =====================
 idAnimator::Allocated
 =====================
 */
 size_t idAnimator::Allocated() const {
 	size_t	size;
 
 	size = jointMods.Allocated() + numJoints * sizeof( joints[0] ) + jointMods.Num() * sizeof( jointMods[ 0 ] ) + AFPoseJointMods.Allocated() + AFPoseJointFrame.Allocated() + AFPoseJoints.Allocated();
 
 	return size;
 }
 
 /*
 =====================
 idAnimator::Save
 
 archives object for save game file
 =====================
 */
 void idAnimator::Save( idSaveGame *savefile ) const {
 	int i;
 	int j;
 
 	savefile->WriteModelDef( modelDef );
 	savefile->WriteObject( entity );
 
 	savefile->WriteInt( jointMods.Num() );
 	for( i = 0; i < jointMods.Num(); i++ ) {
 		savefile->WriteInt( jointMods[ i ]->jointnum );
 		savefile->WriteMat3( jointMods[ i ]->mat );
 		savefile->WriteVec3( jointMods[ i ]->pos );
 		savefile->WriteInt( (int&)jointMods[ i ]->transform_pos );
 		savefile->WriteInt( (int&)jointMods[ i ]->transform_axis );
 	}
 	
 	savefile->WriteInt( numJoints );
 	for ( i = 0; i < numJoints; i++ ) {
 		float *data = joints[i].ToFloatPtr();
 		for ( j = 0; j < 12; j++ ) {
 			savefile->WriteFloat( data[j] );
 		}
 	}
 
 	savefile->WriteInt( lastTransformTime );
 	savefile->WriteBool( stoppedAnimatingUpdate );
 	savefile->WriteBool( forceUpdate );
 	savefile->WriteBounds( frameBounds );
 
 	savefile->WriteFloat( AFPoseBlendWeight );
 
 	savefile->WriteInt( AFPoseJoints.Num() );
 	for ( i = 0; i < AFPoseJoints.Num(); i++ ) {
 		savefile->WriteInt( AFPoseJoints[i] );
 	}
 	
 	savefile->WriteInt( AFPoseJointMods.Num() );
 	for ( i = 0; i < AFPoseJointMods.Num(); i++ ) {
 		savefile->WriteInt( (int&)AFPoseJointMods[i].mod );
 		savefile->WriteMat3( AFPoseJointMods[i].axis );
 		savefile->WriteVec3( AFPoseJointMods[i].origin );
 	}
 	
 	savefile->WriteInt( AFPoseJointFrame.Num() );
 	for ( i = 0; i < AFPoseJointFrame.Num(); i++ ) {
 		savefile->WriteFloat( AFPoseJointFrame[i].q.x );
 		savefile->WriteFloat( AFPoseJointFrame[i].q.y );
 		savefile->WriteFloat( AFPoseJointFrame[i].q.z );
 		savefile->WriteFloat( AFPoseJointFrame[i].q.w );
 		savefile->WriteVec3( AFPoseJointFrame[i].t );
 	}
 	
 	savefile->WriteBounds( AFPoseBounds );
 	savefile->WriteInt( AFPoseTime );
 
 	savefile->WriteBool( removeOriginOffset );
 
 	for( i = ANIMCHANNEL_ALL; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++ ) {
 			channels[ i ][ j ].Save( savefile );
 		}
 	}
 }
 
 /*
 =====================
 idAnimator::Restore
 
 unarchives object from save game file
 =====================
 */
 void idAnimator::Restore( idRestoreGame *savefile ) {
 	int i;
 	int j;
 	int num;
 
 	savefile->ReadModelDef( modelDef );
 	savefile->ReadObject( reinterpret_cast<idClass *&>( entity ) );
 
 	savefile->ReadInt( num );
 	jointMods.SetNum( num );
 	for( i = 0; i < num; i++ ) {
 		jointMods[ i ] = new (TAG_ANIM) jointMod_t;
 		savefile->ReadInt( (int&)jointMods[ i ]->jointnum );
 		savefile->ReadMat3( jointMods[ i ]->mat );
 		savefile->ReadVec3( jointMods[ i ]->pos );
 		savefile->ReadInt( (int&)jointMods[ i ]->transform_pos );
 		savefile->ReadInt( (int&)jointMods[ i ]->transform_axis );
 	}
 	
 	savefile->ReadInt( numJoints );
 	joints = (idJointMat *) Mem_Alloc16( SIMD_ROUND_JOINTS( numJoints ) * sizeof( joints[0] ), TAG_JOINTMAT );
 	for ( i = 0; i < numJoints; i++ ) {
 		float *data = joints[i].ToFloatPtr();
 		for ( j = 0; j < 12; j++ ) {
 			savefile->ReadFloat( data[j] );
 		}
 	}
 	SIMD_INIT_LAST_JOINT( joints, numJoints );
 	
 	savefile->ReadInt( lastTransformTime );
 	savefile->ReadBool( stoppedAnimatingUpdate );
 	savefile->ReadBool( forceUpdate );
 	savefile->ReadBounds( frameBounds );
 
 	savefile->ReadFloat( AFPoseBlendWeight );
 
 	savefile->ReadInt( num );
 	AFPoseJoints.SetGranularity( 1 );
 	AFPoseJoints.SetNum( num );
 	for ( i = 0; i < AFPoseJoints.Num(); i++ ) {
 		savefile->ReadInt( AFPoseJoints[i] );
 	}
 	
 	savefile->ReadInt( num );
 	AFPoseJointMods.SetGranularity( 1 );
 	AFPoseJointMods.SetNum( num );
 	for ( i = 0; i < AFPoseJointMods.Num(); i++ ) {
 		savefile->ReadInt( (int&)AFPoseJointMods[i].mod );
 		savefile->ReadMat3( AFPoseJointMods[i].axis );
 		savefile->ReadVec3( AFPoseJointMods[i].origin );
 	}
 	
 	savefile->ReadInt( num );
 	AFPoseJointFrame.SetGranularity( 1 );
 	AFPoseJointFrame.SetNum( num );
 	for ( i = 0; i < AFPoseJointFrame.Num(); i++ ) {
 		savefile->ReadFloat( AFPoseJointFrame[i].q.x );
 		savefile->ReadFloat( AFPoseJointFrame[i].q.y );
 		savefile->ReadFloat( AFPoseJointFrame[i].q.z );
 		savefile->ReadFloat( AFPoseJointFrame[i].q.w );
 		savefile->ReadVec3( AFPoseJointFrame[i].t );
 	}
 	
 	savefile->ReadBounds( AFPoseBounds );
 	savefile->ReadInt( AFPoseTime );
 
 	savefile->ReadBool( removeOriginOffset );
 
 	for( i = ANIMCHANNEL_ALL; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++ ) {
 			channels[ i ][ j ].Restore( savefile, modelDef );
 		}
 	}
 }
 
 /*
 =====================
 idAnimator::FreeData
 =====================
 */
 void idAnimator::FreeData() {
 	int	i, j;
 
 	if ( entity ) {
 		entity->BecomeInactive( TH_ANIMATE );
 	}
 
 	for( i = ANIMCHANNEL_ALL; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++ ) {
 			channels[ i ][ j ].Reset( NULL );
 		}
 	}
 
 	jointMods.DeleteContents( true );
 
 	Mem_Free16( joints );
 	joints = NULL;
 	numJoints = 0;
 
 	modelDef = NULL;
 
 	ForceUpdate();
 }
 
 /*
 =====================
 idAnimator::PushAnims
 =====================
 */
 void idAnimator::PushAnims( int channelNum, int currentTime, int blendTime ) {
 	int			i;
 	idAnimBlend *channel;
 
 	channel = channels[ channelNum ];
 	if ( !channel[ 0 ].GetWeight( currentTime ) || ( channel[ 0 ].starttime == currentTime ) ) {
 		return;
 	}
 
 	for( i = ANIM_MaxAnimsPerChannel - 1; i > 0; i-- ) {
 		channel[ i ] = channel[ i - 1 ];
 	}
 
 	channel[ 0 ].Reset( modelDef );
 	channel[ 1 ].Clear( currentTime, blendTime );
 	ForceUpdate();
 }
 
 /*
 =====================
 idAnimator::SetModel
 =====================
 */
 idRenderModel *idAnimator::SetModel( const char *modelname ) {
 	int i, j;
 
 	FreeData();
 
 	// check if we're just clearing the model
 	if ( !modelname || !*modelname ) {
 		return NULL;
 	}
 
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, modelname, false ) );
 	if ( !modelDef ) {
 		return NULL;
 	}
 	
 	idRenderModel *renderModel = modelDef->ModelHandle();
 	if ( !renderModel ) {
 		modelDef = NULL;
 		return NULL;
 	}
 
 	// make sure model hasn't been purged
 	modelDef->Touch();
 
 	modelDef->SetupJoints( &numJoints, &joints, frameBounds, removeOriginOffset );
 	modelDef->ModelHandle()->Reset();
 
 	// set the modelDef on all channels
 	for( i = ANIMCHANNEL_ALL; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++ ) {
 			channels[ i ][ j ].Reset( modelDef );
 		}
 	}
 
 	return modelDef->ModelHandle();
 }
 
 /*
 =====================
 idAnimator::Size
 =====================
 */
 size_t idAnimator::Size() const {
 	return sizeof( *this ) + Allocated();
 }
 
 /*
 =====================
 idAnimator::SetEntity
 =====================
 */
 void idAnimator::SetEntity( idEntity *ent ) {
 	entity = ent;
 }
 
 /*
 =====================
 idAnimator::GetEntity
 =====================
 */
 idEntity *idAnimator::GetEntity() const {
 	return entity;
 }
 
 /*
 =====================
 idAnimator::RemoveOriginOffset
 =====================
 */
 void idAnimator::RemoveOriginOffset( bool remove ) {
 	removeOriginOffset = remove;
 }
 
 /*
 =====================
 idAnimator::RemoveOrigin
 =====================
 */
 bool idAnimator::RemoveOrigin() const {
 	return removeOriginOffset;
 }
 
 /*
 =====================
 idAnimator::GetJointList
 =====================
 */
 void idAnimator::GetJointList( const char *jointnames, idList<jointHandle_t> &jointList ) const {
 	if ( modelDef ) {
 		modelDef->GetJointList( jointnames, jointList );
 	}
 }
 
 /*
 =====================
 idAnimator::NumAnims
 =====================
 */
 int	idAnimator::NumAnims() const {
 	if ( !modelDef ) {
 		return 0;
 	}
 	
 	return modelDef->NumAnims();
 }
 
 /*
 =====================
 idAnimator::GetAnim
 =====================
 */
 const idAnim *idAnimator::GetAnim( int index ) const {
 	if ( !modelDef ) {
 		return NULL;
 	}
 	
 	return modelDef->GetAnim( index );
 }
 
 /*
 =====================
 idAnimator::GetAnim
 =====================
 */
 int idAnimator::GetAnim( const char *name ) const {
 	if ( !modelDef ) {
 		return 0;
 	}
 	
 	return modelDef->GetAnim( name );
 }
 
 /*
 =====================
 idAnimator::HasAnim
 =====================
 */
 bool idAnimator::HasAnim( const char *name ) const {
 	if ( !modelDef ) {
 		return false;
 	}
 	
 	return modelDef->HasAnim( name );
 }
 
 /*
 =====================
 idAnimator::NumJoints
 =====================
 */
 int	idAnimator::NumJoints() const {
 	return numJoints;
 }
 
 /*
 =====================
 idAnimator::ModelHandle
 =====================
 */
 idRenderModel *idAnimator::ModelHandle() const {
 	if ( !modelDef ) {
 		return NULL;
 	}
 	
 	return modelDef->ModelHandle();
 }
 
 /*
 =====================
 idAnimator::ModelDef
 =====================
 */
 const idDeclModelDef *idAnimator::ModelDef() const {
 	return modelDef;
 }
 
 /*
 =====================
 idAnimator::CurrentAnim
 =====================
 */
 idAnimBlend *idAnimator::CurrentAnim( int channelNum ) {
 	if ( ( channelNum < 0 ) || ( channelNum >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idAnimator::CurrentAnim : channel out of range" );
 		return NULL;
 	}
 
 	return &channels[ channelNum ][ 0 ];
 }
 
 /*
 =====================
 idAnimator::Clear
 =====================
 */
 void idAnimator::Clear( int channelNum, int currentTime, int cleartime ) {
 	int			i;
 	idAnimBlend	*blend;
 
 	if ( ( channelNum < 0 ) || ( channelNum >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idAnimator::Clear : channel out of range" );
 		return;
 	}
 
 	blend = channels[ channelNum ];
 	for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 		blend->Clear( currentTime, cleartime );
 	}
 	ForceUpdate();
 }
 
 /*
 =====================
 idAnimator::SetFrame
 =====================
 */
 void idAnimator::SetFrame( int channelNum, int animNum, int frame, int currentTime, int blendTime ) {
 	if ( ( channelNum < 0 ) || ( channelNum >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idAnimator::SetFrame : channel out of range" );
 	}
 
 	if ( !modelDef || !modelDef->GetAnim( animNum ) ) {
 		return;
 	}
 
 	PushAnims( channelNum, currentTime, blendTime );
 	channels[ channelNum ][ 0 ].SetFrame( modelDef, animNum, frame, currentTime, blendTime );
 	if ( entity ) {
 		entity->BecomeActive( TH_ANIMATE );
 	}
 }
 
 /*
 =====================
 idAnimator::CycleAnim
 =====================
 */
 void idAnimator::CycleAnim( int channelNum, int animNum, int currentTime, int blendTime ) {
 	if ( ( channelNum < 0 ) || ( channelNum >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idAnimator::CycleAnim : channel out of range" );
 	}
 
 	if ( !modelDef || !modelDef->GetAnim( animNum ) ) {
 		return;
 	}
 	
 	PushAnims( channelNum, currentTime, blendTime );
 	channels[ channelNum ][ 0 ].CycleAnim( modelDef, animNum, currentTime, blendTime );
 	if ( entity ) {
 		entity->BecomeActive( TH_ANIMATE );
 	}
 }
 
 /*
 =====================
 idAnimator::PlayAnim
 =====================
 */
 void idAnimator::PlayAnim( int channelNum, int animNum, int currentTime, int blendTime ) {
 	if ( ( channelNum < 0 ) || ( channelNum >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idAnimator::PlayAnim : channel out of range" );
 	}
 
 	if ( !modelDef || !modelDef->GetAnim( animNum ) ) {
 		return;
 	}
 	
 	PushAnims( channelNum, currentTime, blendTime );
 	channels[ channelNum ][ 0 ].PlayAnim( modelDef, animNum, currentTime, blendTime );
 	if ( entity ) {
 		entity->BecomeActive( TH_ANIMATE );
 	}
 }
 
 /*
 =====================
 idAnimator::SyncAnimChannels
 =====================
 */
 void idAnimator::SyncAnimChannels( int channelNum, int fromChannelNum, int currentTime, int blendTime ) {
 	if ( ( channelNum < 0 ) || ( channelNum >= ANIM_NumAnimChannels ) || ( fromChannelNum < 0 ) || ( fromChannelNum >= ANIM_NumAnimChannels ) ) {
 		gameLocal.Error( "idAnimator::SyncToChannel : channel out of range" );
 		return;
 	}
 
 	idAnimBlend &fromBlend = channels[ fromChannelNum ][ 0 ];
 	idAnimBlend &toBlend = channels[ channelNum ][ 0 ];
 
 	float weight = fromBlend.blendEndValue;
 	if ( ( fromBlend.Anim() != toBlend.Anim() ) || ( fromBlend.GetStartTime() != toBlend.GetStartTime() ) || ( fromBlend.GetEndTime() != toBlend.GetEndTime() ) ) {
 		PushAnims( channelNum, currentTime, blendTime );
 		toBlend = fromBlend;
 		toBlend.blendStartValue = 0.0f;
 		toBlend.blendEndValue = 0.0f;
 	}
     toBlend.SetWeight( weight, currentTime - 1, blendTime );
 
 	// disable framecommands on the current channel so that commands aren't called twice
 	toBlend.AllowFrameCommands( false );
 
 	if ( entity ) {
 		entity->BecomeActive( TH_ANIMATE );
 	}
 }
 
 /*
 =====================
 idAnimator::SetJointPos
 =====================
 */
 void idAnimator::SetJointPos( jointHandle_t jointnum, jointModTransform_t transform_type, const idVec3 &pos ) {
 	int i;
 	jointMod_t *jointMod;
 
 	if ( !modelDef || !modelDef->ModelHandle() || ( jointnum < 0 ) || ( jointnum >= numJoints ) ) {
 		return;
 	}
 
 	jointMod = NULL;
 	for( i = 0; i < jointMods.Num(); i++ ) {
 		if ( jointMods[ i ]->jointnum == jointnum ) {
 			jointMod = jointMods[ i ];
 			break;
 		} else if ( jointMods[ i ]->jointnum > jointnum ) {
 			break;
 		}
 	}
 
 	if ( !jointMod ) {
 		jointMod = new (TAG_ANIM) jointMod_t;
 		jointMod->jointnum = jointnum;
 		jointMod->mat.Identity();
 		jointMod->transform_axis = JOINTMOD_NONE;
 		jointMods.Insert( jointMod, i );
 	}
 
 	jointMod->pos = pos;
 	jointMod->transform_pos = transform_type;
 
 	if ( entity ) {
 		entity->BecomeActive( TH_ANIMATE );
 	}
 	ForceUpdate();
 }
 
 /*
 =====================
 idAnimator::SetJointAxis
 =====================
 */
 void idAnimator::SetJointAxis( jointHandle_t jointnum, jointModTransform_t transform_type, const idMat3 &mat ) {
 	int i;
 	jointMod_t *jointMod;
 
 	if ( !modelDef || !modelDef->ModelHandle() || ( jointnum < 0 ) || ( jointnum >= numJoints ) ) {
 		return;
 	}
 
 	jointMod = NULL;
 	for( i = 0; i < jointMods.Num(); i++ ) {
 		if ( jointMods[ i ]->jointnum == jointnum ) {
 			jointMod = jointMods[ i ];
 			break;
 		} else if ( jointMods[ i ]->jointnum > jointnum ) {
 			break;
 		}
 	}
 
 	if ( !jointMod ) {
 		jointMod = new (TAG_ANIM) jointMod_t;
 		jointMod->jointnum = jointnum;
 		jointMod->pos.Zero();
 		jointMod->transform_pos = JOINTMOD_NONE;
 		jointMods.Insert( jointMod, i );
 	}
 
 	jointMod->mat = mat;
 	jointMod->transform_axis = transform_type;
 
 	if ( entity ) {
 		entity->BecomeActive( TH_ANIMATE );
 	}
 	ForceUpdate();
 }
 
 /*
 =====================
 idAnimator::ClearJoint
 =====================
 */
 void idAnimator::ClearJoint( jointHandle_t jointnum ) {
 	int i;
 
 	if ( !modelDef || !modelDef->ModelHandle() || ( jointnum < 0 ) || ( jointnum >= numJoints ) ) {
 		return;
 	}
 
 	for( i = 0; i < jointMods.Num(); i++ ) {
 		if ( jointMods[ i ]->jointnum == jointnum ) {
 			delete jointMods[ i ];
 			jointMods.RemoveIndex( i );
 			ForceUpdate();
 			break;
 		} else if ( jointMods[ i ]->jointnum > jointnum ) {
 			break;
 		}
 	}
 }
 
 /*
 =====================
 idAnimator::ClearAllJoints
 =====================
 */
 void idAnimator::ClearAllJoints() {
 	if ( jointMods.Num() ) {
 		ForceUpdate();
 	}
 	jointMods.DeleteContents( true );
 }
 
 /*
 =====================
 idAnimator::ClearAllAnims
 =====================
 */
 void idAnimator::ClearAllAnims( int currentTime, int cleartime ) {
 	int	i;
 
 	for( i = 0; i < ANIM_NumAnimChannels; i++ ) {
 		Clear( i, currentTime, cleartime );
 	}
 
 	ClearAFPose();
 	ForceUpdate();
 }
 
 /*
 ====================
 idAnimator::GetDelta
 ====================
 */
 void idAnimator::GetDelta( int fromtime, int totime, idVec3 &delta ) const {
 	int					i;
 	const idAnimBlend	*blend;
 	float				blendWeight;
 
 	if ( !modelDef || !modelDef->ModelHandle() || ( fromtime == totime ) ) {
 		delta.Zero();
 		return;
 	}
 
 	delta.Zero();
 	blendWeight = 0.0f;
 
 	blend = channels[ ANIMCHANNEL_ALL ];
 	for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 		blend->BlendDelta( fromtime, totime, delta, blendWeight );
 	}
 
 	if ( modelDef->Joints()[ 0 ].channel ) {
 		blend = channels[ modelDef->Joints()[ 0 ].channel ];
 		for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 			blend->BlendDelta( fromtime, totime, delta, blendWeight );
 		}
 	}
 }
 
 /*
 ====================
 idAnimator::GetDeltaRotation
 ====================
 */
 bool idAnimator::GetDeltaRotation( int fromtime, int totime, idMat3 &delta ) const {
 	int					i;
 	const idAnimBlend	*blend;
 	float				blendWeight;
 	idQuat				q;
 
 	if ( !modelDef || !modelDef->ModelHandle() || ( fromtime == totime ) ) {
 		delta.Identity();
 		return false;
 	}
 
 	q.Set( 0.0f, 0.0f, 0.0f, 1.0f );
 	blendWeight = 0.0f;
 
 	blend = channels[ ANIMCHANNEL_ALL ];
 	for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 		blend->BlendDeltaRotation( fromtime, totime, q, blendWeight );
 	}
 
 	if ( modelDef->Joints()[ 0 ].channel ) {
 		blend = channels[ modelDef->Joints()[ 0 ].channel ];
 		for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 			blend->BlendDeltaRotation( fromtime, totime, q, blendWeight );
 		}
 	}
 
 	if ( blendWeight > 0.0f ) {
 		delta = q.ToMat3();
 		return true;
 	} else {
 		delta.Identity();
 		return false;
 	}
 }
 
 /*
 ====================
 idAnimator::GetOrigin
 ====================
 */
 void idAnimator::GetOrigin( int currentTime, idVec3 &pos ) const {
 	int					i;
 	const idAnimBlend	*blend;
 	float				blendWeight;
 
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		pos.Zero();
 		return;
 	}
 
 	pos.Zero();
 	blendWeight = 0.0f;
 
 	blend = channels[ ANIMCHANNEL_ALL ];
 	for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 		blend->BlendOrigin( currentTime, pos, blendWeight, removeOriginOffset );
 	}
 
 	if ( modelDef->Joints()[ 0 ].channel ) {
 		blend = channels[ modelDef->Joints()[ 0 ].channel ];
 		for( i = 0; i < ANIM_MaxAnimsPerChannel; i++, blend++ ) {
 			blend->BlendOrigin( currentTime, pos, blendWeight, removeOriginOffset );
 		}
 	}
 
 	pos += modelDef->GetVisualOffset();
 }
 
 /*
 ====================
 idAnimator::GetBounds
 ====================
 */
 bool idAnimator::GetBounds( int currentTime, idBounds &bounds ) {
 	int					i, j;
 	const idAnimBlend	*blend;
 	int					count;
 
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		return false;
 	}
 
 	if ( AFPoseJoints.Num() ) {
 		bounds = AFPoseBounds;
 		count = 1;
 	} else {
 		bounds.Clear();
 		count = 0;
 	}
 
 	blend = channels[ 0 ];
 	for( i = ANIMCHANNEL_ALL; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 			if ( blend->AddBounds( currentTime, bounds, removeOriginOffset ) ) {
 				count++;
 			}
 		}
 	}
 
 	if ( !count ) {
 		if ( !frameBounds.IsCleared() ) {
 			bounds = frameBounds;
 			return true;
 		} else {
 			bounds.Zero();
 			return false;
 		}
 	}
 
 	bounds.TranslateSelf( modelDef->GetVisualOffset() );
 
 	if ( g_debugBounds.GetBool() ) {
 		if ( bounds[1][0] - bounds[0][0] > 2048 || bounds[1][1] - bounds[0][1] > 2048 ) {
 			if ( entity ) {
 				gameLocal.Warning( "big frameBounds on entity '%s' with model '%s': %f,%f", entity->name.c_str(), modelDef->ModelHandle()->Name(), bounds[1][0] - bounds[0][0], bounds[1][1] - bounds[0][1] );
 			} else {
 				gameLocal.Warning( "big frameBounds on model '%s': %f,%f", modelDef->ModelHandle()->Name(), bounds[1][0] - bounds[0][0], bounds[1][1] - bounds[0][1] );
 			}
 		}
 	}
 
 	frameBounds = bounds;
 
 	return true;
 }
 
 /*
 =====================
 idAnimator::InitAFPose
 =====================
 */
 void idAnimator::InitAFPose() {
 
 	if ( !modelDef ) {
 		return;
 	}
 
 	AFPoseJoints.SetNum( modelDef->Joints().Num() );
 	AFPoseJoints.SetNum( 0 );
 	AFPoseJointMods.SetNum( modelDef->Joints().Num() );
 	AFPoseJointFrame.SetNum( modelDef->Joints().Num() );
 }
 
 /*
 =====================
 idAnimator::SetAFPoseJointMod
 =====================
 */
 void idAnimator::SetAFPoseJointMod( const jointHandle_t jointNum, const AFJointModType_t mod, const idMat3 &axis, const idVec3 &origin ) {
 	AFPoseJointMods[jointNum].mod = mod;
 	AFPoseJointMods[jointNum].axis = axis;
 	AFPoseJointMods[jointNum].origin = origin;
 
 	int index = idBinSearch_GreaterEqual<int>( AFPoseJoints.Ptr(), AFPoseJoints.Num(), jointNum );
 	if ( index >= AFPoseJoints.Num() || jointNum != AFPoseJoints[index] ) {
 		AFPoseJoints.Insert( jointNum, index );
 	}
 }
 
 /*
 =====================
 idAnimator::FinishAFPose
 =====================
 */
 void idAnimator::FinishAFPose( int animNum, const idBounds &bounds, const int time ) {
 	int					i, j;
 	int					numJoints;
 	int					parentNum;
 	int					jointMod;
 	int					jointNum;
 	const int *			jointParent;
 
 	if ( !modelDef ) {
 		return;
 	}
 	
 	const idAnim *anim = modelDef->GetAnim( animNum );
 	if ( !anim ) {
 		return;
 	}
 
 	numJoints = modelDef->Joints().Num();
 	if ( !numJoints ) {
 		return;
 	}
 
 	idRenderModel		*md5 = modelDef->ModelHandle();
 	const idMD5Anim		*md5anim = anim->MD5Anim( 0 );
 
 	if ( numJoints != md5anim->NumJoints() ) {
 		gameLocal.Warning( "Model '%s' has different # of joints than anim '%s'", md5->Name(), md5anim->Name() );
 		return;
 	}
 
 	idJointQuat *jointFrame = ( idJointQuat * )_alloca16( numJoints * sizeof( *jointFrame ) );
 	md5anim->GetSingleFrame( 0, jointFrame, modelDef->GetChannelJoints( ANIMCHANNEL_ALL ), modelDef->NumJointsOnChannel( ANIMCHANNEL_ALL ) );
 
 	if ( removeOriginOffset ) {
 #ifdef VELOCITY_MOVE
 		jointFrame[ 0 ].t.x = 0.0f;
 #else
 		jointFrame[ 0 ].t.Zero();
 #endif
 	}
 
 	idJointMat *joints = ( idJointMat * )_alloca16( numJoints * sizeof( *joints ) );
 
 	// convert the joint quaternions to joint matrices
 	SIMDProcessor->ConvertJointQuatsToJointMats( joints, jointFrame, numJoints );
 
 	// first joint is always root of entire hierarchy
 	if ( AFPoseJoints.Num() && AFPoseJoints[0] == 0 ) {
 		switch( AFPoseJointMods[0].mod ) {
 			case AF_JOINTMOD_AXIS: {
 				joints[0].SetRotation( AFPoseJointMods[0].axis );
 				break;
 			}
 			case AF_JOINTMOD_ORIGIN: {
 				joints[0].SetTranslation( AFPoseJointMods[0].origin );
 				break;
 			}
 			case AF_JOINTMOD_BOTH: {
 				joints[0].SetRotation( AFPoseJointMods[0].axis );
 				joints[0].SetTranslation( AFPoseJointMods[0].origin );
 				break;
 			}
 		}
 		j = 1;
 	} else {
 		j = 0;
 	}
 
 	// pointer to joint info
 	jointParent = modelDef->JointParents();
 
 	// transform the child joints
 	for( i = 1; j < AFPoseJoints.Num(); j++, i++ ) {
 		jointMod = AFPoseJoints[j];
 
 		// transform any joints preceding the joint modifier
 		SIMDProcessor->TransformJoints( joints, jointParent, i, jointMod - 1 );
 		i = jointMod;
 
 		parentNum = jointParent[i];
 
 		switch( AFPoseJointMods[jointMod].mod ) {
 			case AF_JOINTMOD_AXIS: {
 				joints[i].SetRotation( AFPoseJointMods[jointMod].axis );
 				joints[i].SetTranslation( joints[parentNum].ToVec3() + joints[i].ToVec3() * joints[parentNum].ToMat3() );
 				break;
 			}
 			case AF_JOINTMOD_ORIGIN: {
 				joints[i].SetRotation( joints[i].ToMat3() * joints[parentNum].ToMat3() );
 				joints[i].SetTranslation( AFPoseJointMods[jointMod].origin );
 				break;
 			}
 			case AF_JOINTMOD_BOTH: {
 				joints[i].SetRotation( AFPoseJointMods[jointMod].axis );
 				joints[i].SetTranslation( AFPoseJointMods[jointMod].origin );
 				break;
 			}
 		}
 	}
 
 	// transform the rest of the hierarchy
 	SIMDProcessor->TransformJoints( joints, jointParent, i, numJoints - 1 );
 
 	// untransform hierarchy
 	SIMDProcessor->UntransformJoints( joints, jointParent, 1, numJoints - 1 );
 
 	// convert joint matrices back to joint quaternions
 	SIMDProcessor->ConvertJointMatsToJointQuats( AFPoseJointFrame.Ptr(), joints, numJoints );
 
 	// find all modified joints and their parents
 	bool *blendJoints = (bool *) _alloca16( numJoints * sizeof( bool ) );
 	memset( blendJoints, 0, numJoints * sizeof( bool ) );
 
 	// mark all modified joints and their parents
 	for( i = 0; i < AFPoseJoints.Num(); i++ ) {
 		for( jointNum = AFPoseJoints[i]; jointNum != INVALID_JOINT; jointNum = jointParent[jointNum] ) {
 			blendJoints[jointNum] = true;
 		}
 	}
 
 	// lock all parents of modified joints
 	AFPoseJoints.SetNum( 0 );
 	for ( i = 0; i < numJoints; i++ ) {
 		if ( blendJoints[i] ) {
 			AFPoseJoints.Append( i );
 		}
 	}
 
 	AFPoseBounds = bounds;
 	AFPoseTime = time;
 
 	ForceUpdate();
 }
 
 /*
 =====================
 idAnimator::SetAFPoseBlendWeight
 =====================
 */
 void idAnimator::SetAFPoseBlendWeight( float blendWeight ) {
 	AFPoseBlendWeight = blendWeight;
 }
 
 /*
 =====================
 idAnimator::BlendAFPose
 =====================
 */
 bool idAnimator::BlendAFPose( idJointQuat *blendFrame ) const {
 
 	if ( !AFPoseJoints.Num() ) {
 		return false;
 	}
 
 	SIMDProcessor->BlendJoints( blendFrame, AFPoseJointFrame.Ptr(), AFPoseBlendWeight, AFPoseJoints.Ptr(), AFPoseJoints.Num() );
 
 	return true;
 }
 
 /*
 =====================
 idAnimator::ClearAFPose
 =====================
 */
 void idAnimator::ClearAFPose() {
 	if ( AFPoseJoints.Num() ) {
 		ForceUpdate();
 	}
 	AFPoseBlendWeight = 1.0f;
 	AFPoseJoints.SetNum( 0 );
 	AFPoseBounds.Clear();
 	AFPoseTime = 0;
 }
 
 /*
 =====================
 idAnimator::ServiceAnims
 =====================
 */
 void idAnimator::ServiceAnims( int fromtime, int totime ) {
 	int			i, j;
 	idAnimBlend	*blend;
 
 	if ( !modelDef ) {
 		return;
 	}
 
 	if ( modelDef->ModelHandle() ) {
 		blend = channels[ 0 ];
 		for( i = 0; i < ANIM_NumAnimChannels; i++ ) {
 			for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 				blend->CallFrameCommands( entity, fromtime, totime );
 			}
 		}
 	}
 
 	if ( !IsAnimating( totime ) ) {
 		stoppedAnimatingUpdate = true;
 		if ( entity ) {
 			entity->BecomeInactive( TH_ANIMATE );
 
 			// present one more time with stopped animations so the renderer can properly recreate interactions
 			entity->BecomeActive( TH_UPDATEVISUALS );
 		}
 	}
 }
 
 /*
 =====================
 idAnimator::IsAnimating
 =====================
 */
 bool idAnimator::IsAnimating( int currentTime ) const {
 	int					i, j;
 	const idAnimBlend	*blend;
 
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		return false;
 	}
 
 	// if animating with an articulated figure
 	if ( AFPoseJoints.Num() && currentTime <= AFPoseTime ) {
 		return true;
 	}
 
 	blend = channels[ 0 ];
 	for( i = 0; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 			if ( !blend->IsDone( currentTime ) ) {
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 /*
 =====================
 idAnimator::FrameHasChanged
 =====================
 */
 bool idAnimator::FrameHasChanged( int currentTime ) const {
 	int					i, j;
 	const idAnimBlend	*blend;
 
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		return false;
 	}
 
 	// if animating with an articulated figure
 	if ( AFPoseJoints.Num() && currentTime <= AFPoseTime ) {
 		return true;
 	}
 
 	blend = channels[ 0 ];
 	for( i = 0; i < ANIM_NumAnimChannels; i++ ) {
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 			if ( blend->FrameHasChanged( currentTime ) ) {
 				return true;
 			}
 		}
 	}
 
 	if ( forceUpdate && IsAnimating( currentTime ) ) {
 		return true;
 	}
 
 	return false;
 }
 
 /*
 =====================
 idAnimator::CreateFrame
 =====================
 */
 bool idAnimator::CreateFrame( int currentTime, bool force ) {
 	int					i, j;
 	int					numJoints;
 	int					parentNum;
 	bool				hasAnim;
 	bool				debugInfo;
 	float				baseBlend;
 	float				blendWeight;
 	const idAnimBlend *	blend;
 	const int *			jointParent;
 	const jointMod_t *	jointMod;
 	const idJointQuat *	defaultPose;
 
 	static idCVar		r_showSkel( "r_showSkel", "0", CVAR_RENDERER | CVAR_INTEGER, "", 0, 2, idCmdSystem::ArgCompletion_Integer<0,2> );
 
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		return false;
 	}
 
 	if ( !force && !r_showSkel.GetInteger() ) {
 		if ( lastTransformTime == currentTime ) {
 			return false;
 		}
 		if ( lastTransformTime != -1 && !stoppedAnimatingUpdate && !IsAnimating( currentTime ) ) {
 			return false;
 		}
 	}
 
 	lastTransformTime = currentTime;
 	stoppedAnimatingUpdate = false;
 
 	if ( entity && ( ( g_debugAnim.GetInteger() == entity->entityNumber ) || ( g_debugAnim.GetInteger() == -2 ) ) ) {
 		debugInfo = true;
 		gameLocal.Printf( "---------------\n%d: entity '%s':\n", gameLocal.time, entity->GetName() );
  		gameLocal.Printf( "model '%s':\n", modelDef->GetModelName() );
 	} else {
 		debugInfo = false;
 	}
 
 	// init the joint buffer
 	if ( AFPoseJoints.Num() ) {
 		// initialize with AF pose anim for the case where there are no other animations and no AF pose joint modifications
 		defaultPose = AFPoseJointFrame.Ptr();
 	} else {
 		defaultPose = modelDef->GetDefaultPose();
 	}
 
 	if ( !defaultPose ) {
 		//gameLocal.Warning( "idAnimator::CreateFrame: no defaultPose on '%s'", modelDef->Name() );
 		return false;
 	}
 
 	numJoints = modelDef->Joints().Num();
 	idJointQuat *jointFrame = ( idJointQuat * )_alloca16( numJoints * sizeof( jointFrame[0] ) );
 	SIMDProcessor->Memcpy( jointFrame, defaultPose, numJoints * sizeof( jointFrame[0] ) );
 
 	hasAnim = false;
 
 	// blend the all channel
 	baseBlend = 0.0f;
 	blend = channels[ ANIMCHANNEL_ALL ];
 	for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 		if ( blend->BlendAnim( currentTime, ANIMCHANNEL_ALL, numJoints, jointFrame, baseBlend, removeOriginOffset, false, debugInfo ) ) {
 			hasAnim = true;
 			if ( baseBlend >= 1.0f ) {
 				break;
 			}
 		}
 	}
 
 	// only blend other channels if there's enough space to blend into
 	if ( baseBlend < 1.0f ) {
 		for( i = ANIMCHANNEL_ALL + 1; i < ANIM_NumAnimChannels; i++ ) {
 			if ( !modelDef->NumJointsOnChannel( i ) ) {
 				continue;
 			}
 			if ( i == ANIMCHANNEL_EYELIDS ) {
 				// eyelids blend over any previous anims, so skip it and blend it later
 				continue;
 			}
 			blendWeight = baseBlend;
 			blend = channels[ i ];
 			for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 				if ( blend->BlendAnim( currentTime, i, numJoints, jointFrame, blendWeight, removeOriginOffset, false, debugInfo ) ) {
 					hasAnim = true;
 					if ( blendWeight >= 1.0f ) {
 						// fully blended
 						break;
 					}
 				}
 			}
 
 			if ( debugInfo && !AFPoseJoints.Num() && !blendWeight ) {
 				gameLocal.Printf( "%d: %s using default pose in model '%s'\n", gameLocal.time, channelNames[ i ], modelDef->GetModelName() );
 			}
 		}
 	}
 
 	// blend in the eyelids
 	if ( modelDef->NumJointsOnChannel( ANIMCHANNEL_EYELIDS ) ) {
 		blend = channels[ ANIMCHANNEL_EYELIDS ];
 		blendWeight = baseBlend;
 		for( j = 0; j < ANIM_MaxAnimsPerChannel; j++, blend++ ) {
 			if ( blend->BlendAnim( currentTime, ANIMCHANNEL_EYELIDS, numJoints, jointFrame, blendWeight, removeOriginOffset, true, debugInfo ) ) {
 				hasAnim = true;
 				if ( blendWeight >= 1.0f ) {
 					// fully blended
 					break;
 				}
 			}
 		}
 	}
 
 	// blend the articulated figure pose
 	if ( BlendAFPose( jointFrame ) ) {
 		hasAnim = true;
 	}
 
 	if ( !hasAnim && !jointMods.Num() ) {
 		// no animations were updated
 		return false;
 	}
 
 	// convert the joint quaternions to rotation matrices
 	SIMDProcessor->ConvertJointQuatsToJointMats( joints, jointFrame, numJoints );
 
 	// check if we need to modify the origin
 	if ( jointMods.Num() && ( jointMods[0]->jointnum == 0 ) ) {
 		jointMod = jointMods[0];
 
 		switch( jointMod->transform_axis ) {
 			case JOINTMOD_NONE:
 				break;
 
 			case JOINTMOD_LOCAL:
 				joints[0].SetRotation( jointMod->mat * joints[0].ToMat3() );
 				break;
 			
 			case JOINTMOD_WORLD:
 				joints[0].SetRotation( joints[0].ToMat3() * jointMod->mat );
 				break;
 
 			case JOINTMOD_LOCAL_OVERRIDE:
 			case JOINTMOD_WORLD_OVERRIDE:
 				joints[0].SetRotation( jointMod->mat );
 				break;
 		}
 
 		switch( jointMod->transform_pos ) {
 			case JOINTMOD_NONE:
 				break;
 
 			case JOINTMOD_LOCAL:
 				joints[0].SetTranslation( joints[0].ToVec3() + jointMod->pos );
 				break;
 			
 			case JOINTMOD_LOCAL_OVERRIDE:
 			case JOINTMOD_WORLD:
 			case JOINTMOD_WORLD_OVERRIDE:
 				joints[0].SetTranslation( jointMod->pos );
 				break;
 		}
 		j = 1;
 	} else {
 		j = 0;
 	}
 
 	// add in the model offset
 	joints[0].SetTranslation( joints[0].ToVec3() + modelDef->GetVisualOffset() );
 
 	// pointer to joint info
 	jointParent = modelDef->JointParents();
 
 	// add in any joint modifications
 	for( i = 1; j < jointMods.Num(); j++, i++ ) {
 		jointMod = jointMods[j];
 
 		// transform any joints preceding the joint modifier
 		SIMDProcessor->TransformJoints( joints, jointParent, i, jointMod->jointnum - 1 );
 		i = jointMod->jointnum;
 
 		parentNum = jointParent[i];
 
 		// modify the axis
 		switch( jointMod->transform_axis ) {
 			case JOINTMOD_NONE:
 				joints[i].SetRotation( joints[i].ToMat3() * joints[ parentNum ].ToMat3() );
 				break;
 
 			case JOINTMOD_LOCAL:
 				joints[i].SetRotation( jointMod->mat * ( joints[i].ToMat3() * joints[parentNum].ToMat3() ) );
 				break;
 			
 			case JOINTMOD_LOCAL_OVERRIDE:
 				joints[i].SetRotation( jointMod->mat * joints[parentNum].ToMat3() );
 				break;
 
 			case JOINTMOD_WORLD:
 				joints[i].SetRotation( ( joints[i].ToMat3() * joints[parentNum].ToMat3() ) * jointMod->mat );
 				break;
 
 			case JOINTMOD_WORLD_OVERRIDE:
 				joints[i].SetRotation( jointMod->mat );
 				break;
 		}
 
 		// modify the position
 		switch( jointMod->transform_pos ) {
 			case JOINTMOD_NONE:
 				joints[i].SetTranslation( joints[parentNum].ToVec3() + joints[i].ToVec3() * joints[parentNum].ToMat3() );
 				break;
 
 			case JOINTMOD_LOCAL:
 				joints[i].SetTranslation( joints[parentNum].ToVec3() + ( joints[i].ToVec3() + jointMod->pos ) * joints[parentNum].ToMat3() );
 				break;
 			
 			case JOINTMOD_LOCAL_OVERRIDE:
 				joints[i].SetTranslation( joints[parentNum].ToVec3() + jointMod->pos * joints[parentNum].ToMat3() );
 				break;
 
 			case JOINTMOD_WORLD:
 				joints[i].SetTranslation( joints[parentNum].ToVec3() + joints[i].ToVec3() * joints[parentNum].ToMat3() + jointMod->pos );
 				break;
 
 			case JOINTMOD_WORLD_OVERRIDE:
 				joints[i].SetTranslation( jointMod->pos );
 				break;
 		}
 	}
 
 	// transform the rest of the hierarchy
 	SIMDProcessor->TransformJoints( joints, jointParent, i, numJoints - 1 );
 
 	return true;
 }
 
 /*
 =====================
 idAnimator::ForceUpdate
 =====================
 */
 void idAnimator::ForceUpdate() {
 	lastTransformTime = -1;
 	forceUpdate = true;
 }
 
 /*
 =====================
 idAnimator::ClearForceUpdate
 =====================
 */
 void idAnimator::ClearForceUpdate() {
 	forceUpdate = false;
 }
 
 /*
 =====================
 idAnimator::GetJointTransform>	gamex86.dll!idAnimator::ForceUpdate()  Line 4268	C++
 
 =====================
 */
 bool idAnimator::GetJointTransform( jointHandle_t jointHandle, int currentTime, idVec3 &offset, idMat3 &axis ) {
 	if ( !modelDef || ( jointHandle < 0 ) || ( jointHandle >= modelDef->NumJoints() ) ) {
 		return false;
 	}
 
 	CreateFrame( currentTime, false );
 
 	offset = joints[ jointHandle ].ToVec3();
 	axis = joints[ jointHandle ].ToMat3();
 
 	return true;
 }
 
 /*
 =====================
 idAnimator::GetJointLocalTransform
 =====================
 */
 bool idAnimator::GetJointLocalTransform( jointHandle_t jointHandle, int currentTime, idVec3 &offset, idMat3 &axis ) {
 	if ( !modelDef ) {
 		return false;
 	}
 
 	const idList<jointInfo_t> &modelJoints = modelDef->Joints();
 
 	if ( ( jointHandle < 0 ) || ( jointHandle >= modelJoints.Num() ) ) {
 		return false;
 	}
 
 	// FIXME: overkill
 	CreateFrame( currentTime, false );
 
 	if ( jointHandle > 0 ) {
 		idJointMat m = joints[ jointHandle ];
 		m /= joints[ modelJoints[ jointHandle ].parentNum ];
 		offset = m.ToVec3();
 		axis = m.ToMat3();
 	} else {
 		offset = joints[ jointHandle ].ToVec3();
 		axis = joints[ jointHandle ].ToMat3();
 	}
 
 	return true;
 }
 
 /*
 =====================
 idAnimator::GetJointHandle
 =====================
 */
 jointHandle_t idAnimator::GetJointHandle( const char *name ) const {
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		return INVALID_JOINT;
 	}
 
 	return modelDef->ModelHandle()->GetJointHandle( name );
 }
 
 /*
 =====================
 idAnimator::GetJointName
 =====================
 */
 const char *idAnimator::GetJointName( jointHandle_t handle ) const {
 	if ( !modelDef || !modelDef->ModelHandle() ) {
 		return "";
 	}
 
 	return modelDef->ModelHandle()->GetJointName( handle );
 }
 
 /*
 =====================
 idAnimator::GetChannelForJoint
 =====================
 */
 int idAnimator::GetChannelForJoint( jointHandle_t joint ) const {
 	if ( !modelDef ) {
 		gameLocal.Error( "idAnimator::GetChannelForJoint: NULL model" );
 		return -1;
 	}
 
 	if ( ( joint < 0 ) || ( joint >= numJoints ) ) {
 		gameLocal.Error( "idAnimator::GetChannelForJoint: invalid joint num (%d)", joint );
 		return -1;
 	}
 
 	return modelDef->GetJoint( joint )->channel;
 }
 
 /*
 =====================
 idAnimator::GetFirstChild
 =====================
 */
 jointHandle_t idAnimator::GetFirstChild( const char *name ) const {
 	return GetFirstChild( GetJointHandle( name ) );
 }
 
 /*
 =====================
 idAnimator::GetFirstChild
 =====================
 */
 jointHandle_t idAnimator::GetFirstChild( jointHandle_t jointnum ) const {
 	int					i;
 	int					num;
 	const jointInfo_t	*joint;
 
 	if ( !modelDef ) {
 		return INVALID_JOINT;
 	}
 
 	num = modelDef->NumJoints();
 	if ( !num ) {
 		return jointnum;
 	}
 	joint = modelDef->GetJoint( 0 );
 	for( i = 0; i < num; i++, joint++ ) {
 		if ( joint->parentNum == jointnum ) {
 			return ( jointHandle_t )joint->num;
 		}
 	}
 	return jointnum;
 }
 
 /*
 =====================
 idAnimator::GetJoints
 =====================
 */
 void idAnimator::GetJoints( int *numJoints, idJointMat **jointsPtr ) {
 	*numJoints = this->numJoints;
 	*jointsPtr = this->joints;
 }
 
 /*
 =====================
 idAnimator::GetAnimFlags
 =====================
 */
 const animFlags_t idAnimator::GetAnimFlags( int animNum ) const {
 	animFlags_t result;
 
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->GetAnimFlags();
 	}
 
 	memset( &result, 0, sizeof( result ) );
 	return result;
 }
 
 /*
 =====================
 idAnimator::NumFrames
 =====================
 */
 int	idAnimator::NumFrames( int animNum ) const {
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->NumFrames();
 	} else {
 		return 0;
 	}
 }
 
 /*
 =====================
 idAnimator::NumSyncedAnims
 =====================
 */
 int	idAnimator::NumSyncedAnims( int animNum ) const {
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->NumAnims();
 	} else {
 		return 0;
 	}
 }
 
 /*
 =====================
 idAnimator::AnimName
 =====================
 */
 const char *idAnimator::AnimName( int animNum ) const {
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->Name();
 	} else {
 		return "";
 	}
 }
 
 /*
 =====================
 idAnimator::AnimFullName
 =====================
 */
 const char *idAnimator::AnimFullName( int animNum ) const {
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->FullName();
 	} else {
 		return "";
 	}
 }
 
 /*
 =====================
 idAnimator::AnimLength
 =====================
 */
 int	idAnimator::AnimLength( int animNum ) const {
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->Length();
 	} else {
 		return 0;
 	}
 }
 
 /*
 =====================
 idAnimator::TotalMovementDelta
 =====================
 */
 const idVec3 &idAnimator::TotalMovementDelta( int animNum ) const {
 	const idAnim *anim = GetAnim( animNum );
 	if ( anim ) {
 		return anim->TotalMovementDelta();
 	} else {
 		return vec3_origin;
 	}
 }
 
 /***********************************************************************
 
 	Util functions
 
 ***********************************************************************/
 
 /*
 =====================
 ANIM_GetModelDefFromEntityDef
 =====================
 */
 const idDeclModelDef *ANIM_GetModelDefFromEntityDef( const idDict *args ) {
 	const idDeclModelDef *modelDef;
 
 	idStr name = args->GetString( "model" );
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, name, false ) );
 	if ( modelDef != NULL && modelDef->ModelHandle() ) {
 		return modelDef;
 	}
 
 	return NULL;
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetModelFromEntityDef
 =====================
 */
 idRenderModel *idGameEdit::ANIM_GetModelFromEntityDef( const idDict *args ) {
 	idRenderModel *model;
 	const idDeclModelDef *modelDef;
 
 	model = NULL;
 
 	idStr name = args->GetString( "model" );
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, name, false ) );
 	if ( modelDef != NULL ) {
 		model = modelDef->ModelHandle();
 	}
 
 	if ( model == NULL ) {
 		model = renderModelManager->FindModel( name );
 	}
 
 	if ( model != NULL && model->IsDefaultModel() ) {
 		return NULL;
 	}
 
 	return model;
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetModelFromEntityDef
 =====================
 */
 idRenderModel *idGameEdit::ANIM_GetModelFromEntityDef( const char *classname ) {
 	const idDict *args;
 
 	args = gameLocal.FindEntityDefDict( classname, false );
 	if ( !args ) {
 		return NULL;
 	}
 
 	return ANIM_GetModelFromEntityDef( args );
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetModelOffsetFromEntityDef
 =====================
 */
 const idVec3 &idGameEdit::ANIM_GetModelOffsetFromEntityDef( const char *classname ) {
 	const idDict *args;
 	const idDeclModelDef *modelDef;
 
 	args = gameLocal.FindEntityDefDict( classname, false );
 	if ( !args ) {
 		return vec3_origin;
 	}
 
 	modelDef = ANIM_GetModelDefFromEntityDef( args );
 	if ( !modelDef ) {
 		return vec3_origin;
 	}
 
 	return modelDef->GetVisualOffset();
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetModelFromName
 =====================
 */
 idRenderModel *idGameEdit::ANIM_GetModelFromName( const char *modelName ) {
 	const idDeclModelDef *modelDef;
 	idRenderModel *model;
 
 	model = NULL;
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, modelName, false ) );
 	if ( modelDef ) {
 		model = modelDef->ModelHandle();
 	}
 	if ( !model ) {
 		model = renderModelManager->FindModel( modelName );
 	}
 	return model;
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetAnimFromEntityDef
 =====================
 */
 const idMD5Anim *idGameEdit::ANIM_GetAnimFromEntityDef( const char *classname, const char *animname ) {
 	const idDict *args;
 	const idMD5Anim *md5anim;
 	const idAnim *anim;
 	int	animNum;
 	const char	*modelname;
 	const idDeclModelDef *modelDef;
 
 	args = gameLocal.FindEntityDefDict( classname, false );
 	if ( !args ) {
 		return NULL;
 	}
 
 	md5anim = NULL;
 	modelname = args->GetString( "model" );
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, modelname, false ) );
 	if ( modelDef ) {
 		animNum = modelDef->GetAnim( animname );
 		if ( animNum ) {
 			anim = modelDef->GetAnim( animNum );
 			if ( anim ) {
 				md5anim = anim->MD5Anim( 0 );
 			}
 		}
 	}
 	return md5anim;
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetNumAnimsFromEntityDef
 =====================
 */
 int idGameEdit::ANIM_GetNumAnimsFromEntityDef( const idDict *args ) {
 	const char *modelname;
 	const idDeclModelDef *modelDef;
 
 	modelname = args->GetString( "model" );
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, modelname, false ) );
 	if ( modelDef ) {
 		return modelDef->NumAnims();
 	}
 	return 0;
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetAnimNameFromEntityDef
 =====================
 */
 const char *idGameEdit::ANIM_GetAnimNameFromEntityDef( const idDict *args, int animNum ) {
 	const char *modelname;
 	const idDeclModelDef *modelDef;
 
 	modelname = args->GetString( "model" );
 	modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, modelname, false ) );
 	if ( modelDef ) {
 		const idAnim* anim = modelDef->GetAnim( animNum );
 		if ( anim ) {
 			return anim->FullName();
 		}
 	}
 	return "";
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetAnim
 =====================
 */
 const idMD5Anim *idGameEdit::ANIM_GetAnim( const char *fileName ) {
 	return animationLib.GetAnim( fileName );
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetLength
 =====================
 */
 int	idGameEdit::ANIM_GetLength( const idMD5Anim *anim ) {
 	if ( !anim ) {
 		return 0;
 	}
 	return anim->Length();
 }
 
 /*
 =====================
 idGameEdit::ANIM_GetNumFrames
 =====================
 */
 int idGameEdit::ANIM_GetNumFrames( const idMD5Anim *anim ) {
 	if ( !anim ) {
 		return 0;
 	}
 	return anim->NumFrames();
 }
 
 /*
 =====================
 idGameEdit::ANIM_CreateAnimFrame
 =====================
 */
 void idGameEdit::ANIM_CreateAnimFrame( const idRenderModel *model, const idMD5Anim *anim, int numJoints, idJointMat *joints, int time, const idVec3 &offset, bool remove_origin_offset ) {
 	int					i;
 	frameBlend_t		frame;
 	const idMD5Joint	*md5joints;
 	int					*index;
 
 	if ( !model || model->IsDefaultModel() || !anim ) {
 		return;
 	}
 
 	if ( numJoints != model->NumJoints() ) {
 		gameLocal.Error( "ANIM_CreateAnimFrame: different # of joints in renderEntity_t than in model (%s)", model->Name() );
 	}
 
 	if ( !model->NumJoints() ) {
 		// FIXME: Print out a warning?
 		return;
 	}
 
 	if ( !joints ) {
 		gameLocal.Error( "ANIM_CreateAnimFrame: NULL joint frame pointer on model (%s)", model->Name() );
 	}
 
 	if ( numJoints != anim->NumJoints() ) {
 		gameLocal.Warning( "Model '%s' has different # of joints than anim '%s'", model->Name(), anim->Name() );
 		for( i = 0; i < numJoints; i++ ) {
 			joints[i].SetRotation( mat3_identity );
 			joints[i].SetTranslation( offset );
 		}
 		return;
 	}
 
 	// create index for all joints
 	index = ( int * )_alloca16( numJoints * sizeof( int ) );
 	for ( i = 0; i < numJoints; i++ ) {
 		index[i] = i;
 	}
 
 	// create the frame
 	anim->ConvertTimeToFrame( time, 1, frame );
 	idJointQuat *jointFrame = ( idJointQuat * )_alloca16( numJoints * sizeof( *jointFrame ) );
 	anim->GetInterpolatedFrame( frame, jointFrame, index, numJoints );
 
 	// convert joint quaternions to joint matrices
 	SIMDProcessor->ConvertJointQuatsToJointMats( joints, jointFrame, numJoints );
 
 	// first joint is always root of entire hierarchy
 	if ( remove_origin_offset ) {
 		joints[0].SetTranslation( offset );
 	} else {
 		joints[0].SetTranslation( joints[0].ToVec3() + offset );
 	}
 
 	// transform the children
 	md5joints = model->GetJoints();
 	for( i = 1; i < numJoints; i++ ) {
 		joints[i] *= joints[ md5joints[i].parent - md5joints ];
 	}
 }
 
 /*
 =====================
 idGameEdit::ANIM_CreateMeshForAnim
 =====================
 */
 idRenderModel *idGameEdit::ANIM_CreateMeshForAnim( idRenderModel *model, const char *classname, const char *animname, int frame, bool remove_origin_offset ) {
 	renderEntity_t			ent;
 	const idDict			*args;
 	const char				*temp;
 	idRenderModel			*newmodel;
 	const idMD5Anim 		*md5anim;
 	idStr					filename;
 	idStr					extension;
 	const idAnim			*anim;
 	int						animNum;
 	idVec3					offset;
 	const idDeclModelDef	*modelDef;
 
 	if ( !model || model->IsDefaultModel() ) {
 		return NULL;
 	}
 
 	args = gameLocal.FindEntityDefDict( classname, false );
 	if ( !args ) {
 		return NULL;
 	}
 
 	memset( &ent, 0, sizeof( ent ) );
 
 	ent.bounds.Clear();
 	ent.suppressSurfaceInViewID = 0;
 
 	modelDef = ANIM_GetModelDefFromEntityDef( args );
 	if ( modelDef ) {
 		animNum = modelDef->GetAnim( animname );
 		if ( !animNum ) {
 			return NULL;
 		}
 		anim = modelDef->GetAnim( animNum );
 		if ( !anim ) {
 			return NULL;
 		}
 		md5anim = anim->MD5Anim( 0 );
 		ent.customSkin = modelDef->GetDefaultSkin();
 		offset = modelDef->GetVisualOffset();
 	} else {
 		filename = animname;
 		filename.ExtractFileExtension( extension );
 		if ( !extension.Length() ) {
 			animname = args->GetString( va( "anim %s", animname ) );
 		}
 
 		md5anim = animationLib.GetAnim( animname );
 		offset.Zero();
 	}
 
 	if ( !md5anim ) {
 		return NULL;
 	}
 
 	temp = args->GetString( "skin", "" );
 	if ( temp[ 0 ] ) {
 		ent.customSkin = declManager->FindSkin( temp );
 	}
 
 	ent.numJoints = model->NumJoints();
 	ent.joints = ( idJointMat * )Mem_Alloc16( SIMD_ROUND_JOINTS( ent.numJoints ) * sizeof( *ent.joints ), TAG_JOINTMAT );
 
 	ANIM_CreateAnimFrame( model, md5anim, ent.numJoints, ent.joints, FRAME2MS( frame ), offset, remove_origin_offset );
 
 	SIMD_INIT_LAST_JOINT( ent.joints, ent.numJoints );
 
 	newmodel = model->InstantiateDynamicModel( &ent, NULL, NULL );
 
 	Mem_Free16( ent.joints );
 	ent.joints = NULL;
 
 	return newmodel;
 }