DOOM-3-BFG

Clip.cpp (47815B)

---

 /*
 ===========================================================================
 
 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"
 
 #define	MAX_SECTOR_DEPTH				12
 #define MAX_SECTORS						((1<<(MAX_SECTOR_DEPTH+1))-1)
 
 typedef struct clipSector_s {
 	int						axis;		// -1 = leaf node
 	float					dist;
 	struct clipSector_s *	children[2];
 	struct clipLink_s *		clipLinks;
 } clipSector_t;
 
 typedef struct clipLink_s {
 	idClipModel *			clipModel;
 	struct clipSector_s *	sector;
 	struct clipLink_s *		prevInSector;
 	struct clipLink_s *		nextInSector;
 	struct clipLink_s *		nextLink;
 } clipLink_t;
 
 typedef struct trmCache_s {
 	idTraceModel			trm;
 	int						refCount;
 	float					volume;
 	idVec3					centerOfMass;
 	idMat3					inertiaTensor;
 } trmCache_t;
 
 idVec3 vec3_boxEpsilon( CM_BOX_EPSILON, CM_BOX_EPSILON, CM_BOX_EPSILON );
 
 idBlockAlloc<clipLink_t, 1024>	clipLinkAllocator;
 
 
 /*
 ===============================================================
 
 	idClipModel trace model cache
 
 ===============================================================
 */
 
 static idList<trmCache_s*>		traceModelCache;
 static idList<trmCache_s*>		traceModelCache_Unsaved;
 static idHashIndex				traceModelHash;
 static idHashIndex				traceModelHash_Unsaved;
 const static int				TRACE_MODEL_SAVED = BIT( 16 );
 
 
 /*
 ===============
 idClipModel::ClearTraceModelCache
 ===============
 */
 void idClipModel::ClearTraceModelCache() {
 	traceModelCache.DeleteContents( true );
 	traceModelCache_Unsaved.DeleteContents( true );
 	traceModelHash.Free();
 	traceModelHash_Unsaved.Free();
 }
 
 /*
 ===============
 idClipModel::TraceModelCacheSize
 ===============
 */
 int idClipModel::TraceModelCacheSize() {
 	return traceModelCache.Num() * sizeof( idTraceModel );
 }
 
 /*
 ===============
 idClipModel::AllocTraceModel
 ===============
 */
 int idClipModel::AllocTraceModel( const idTraceModel &trm, bool persistantThroughSaves ) {
 	int i, hashKey, traceModelIndex;
 	trmCache_t *entry;
 
 	hashKey = GetTraceModelHashKey( trm );
 
 	if( persistantThroughSaves ) {
 		// Look Inside the saved list.
 		for ( i = traceModelHash.First( hashKey ); i >= 0; i = traceModelHash.Next( i ) ) {
 			if ( traceModelCache[i]->trm == trm ) {
 				traceModelCache[i]->refCount++;
 				int flagged_index = i | TRACE_MODEL_SAVED;
 				return flagged_index;
 			}
 		}
 	} else {
 
 		// Look inside the unsaved list.
 		for ( i = traceModelHash_Unsaved.First( hashKey ); i >= 0; i = traceModelHash_Unsaved.Next( i ) ) {
 			if ( traceModelCache_Unsaved[i]->trm == trm ) {
 				traceModelCache_Unsaved[i]->refCount++;
 				return i;
 			}
 		}
 	}
 
 
 	entry = new (TAG_PHYSICS_CLIP) trmCache_t;
 	entry->trm = trm;
 	entry->trm.GetMassProperties( 1.0f, entry->volume, entry->centerOfMass, entry->inertiaTensor );
 	entry->refCount = 1;
 
 	if( persistantThroughSaves ) {
 		traceModelIndex = traceModelCache.Append( entry );
 		traceModelHash.Add( hashKey, traceModelIndex );
 
 		// Set the saved bit.
 		traceModelIndex |= TRACE_MODEL_SAVED;
 
 	} else {
 		traceModelIndex = traceModelCache_Unsaved.Append( entry );
 		traceModelHash_Unsaved.Add( hashKey, traceModelIndex );
 
 		// remove the saved bit
 		traceModelIndex &= ~TRACE_MODEL_SAVED;
 
 	}
 
 	return traceModelIndex;
 }
 
 /*
 ===============
 idClipModel::FreeTraceModel
 ===============
 */
 void idClipModel::FreeTraceModel( int traceModelIndex ) {
 
 	int realTraceModelIndex = traceModelIndex & ~TRACE_MODEL_SAVED;
 
 	// Check which cache we are using.
 	if( traceModelIndex & TRACE_MODEL_SAVED ) {
 
 		if ( realTraceModelIndex < 0 || realTraceModelIndex >= traceModelCache.Num() || traceModelCache[realTraceModelIndex]->refCount <= 0 ) {
 			gameLocal.Warning( "idClipModel::FreeTraceModel: tried to free uncached trace model" );
 			return;
 		}
 		traceModelCache[realTraceModelIndex]->refCount--;
 
 	} else {
 
 		if ( realTraceModelIndex < 0 || realTraceModelIndex >= traceModelCache_Unsaved.Num() || traceModelCache_Unsaved[realTraceModelIndex]->refCount <= 0 ) {
 			gameLocal.Warning( "idClipModel::FreeTraceModel: tried to free uncached trace model" );
 			return;
 		}
 		traceModelCache_Unsaved[realTraceModelIndex]->refCount--;
 
 	}
 }
 
 /*
 ===============
 idClipModel::GetCachedTraceModel
 ===============
 */
 idTraceModel *idClipModel::GetCachedTraceModel( int traceModelIndex ) {
 	int realTraceModelIndex = traceModelIndex & ~TRACE_MODEL_SAVED;
 
 	if( traceModelIndex & TRACE_MODEL_SAVED ) {
 		return &traceModelCache[realTraceModelIndex]->trm;
 	} else {
 		return &traceModelCache_Unsaved[realTraceModelIndex]->trm;
 	}
 }
 
 /*
 ===============
 idClipModel::GetCachedTraceModel
 ===============
 */
 trmCache_t * idClipModel::GetTraceModelEntry( int traceModelIndex ) {
 
 	int realTraceModelIndex = traceModelIndex & ~TRACE_MODEL_SAVED;
 
 	if( traceModelIndex & TRACE_MODEL_SAVED ) {
 		return traceModelCache[realTraceModelIndex];
 	} else {
 		return traceModelCache_Unsaved[realTraceModelIndex];
 	}
 }
 
 /*
 ===============
 idClipModel::GetTraceModelHashKey
 ===============
 */
 int idClipModel::GetTraceModelHashKey( const idTraceModel &trm ) {
 	const idVec3 &v = trm.bounds[0];
 	return ( trm.type << 8 ) ^ ( trm.numVerts << 4 ) ^ ( trm.numEdges << 2 ) ^ ( trm.numPolys << 0 ) ^ idMath::FloatHash( v.ToFloatPtr(), v.GetDimension() );
 }
 
 /*
 ===============
 idClipModel::SaveTraceModels
 ===============
 */
 void idClipModel::SaveTraceModels( idSaveGame *savefile ) {
 	int i;
 
 	savefile->WriteInt( traceModelCache.Num() );
 	for ( i = 0; i < traceModelCache.Num(); i++ ) {
 		trmCache_t *entry = traceModelCache[i];
 		
 		savefile->WriteTraceModel( entry->trm );
 		savefile->WriteFloat( entry->volume );
 		savefile->WriteVec3( entry->centerOfMass );
 		savefile->WriteMat3( entry->inertiaTensor );
 	}
 }
 
 /*
 ===============
 idClipModel::RestoreTraceModels
 ===============
 */
 void idClipModel::RestoreTraceModels( idRestoreGame *savefile ) {
 	int i, num;
 
 	ClearTraceModelCache();
 
 	savefile->ReadInt( num );
 	traceModelCache.SetNum( num );
 
 	for ( i = 0; i < num; i++ ) {
 		trmCache_t *entry = new (TAG_PHYSICS_CLIP) trmCache_t;
 		
 		savefile->ReadTraceModel( entry->trm );
 
 		savefile->ReadFloat( entry->volume );
 		savefile->ReadVec3( entry->centerOfMass );
 		savefile->ReadMat3( entry->inertiaTensor );
 		entry->refCount = 0;
 
 		traceModelCache[i] = entry;
 		traceModelHash.Add( GetTraceModelHashKey( entry->trm ), i );
 	}
 }
 
 
 /*
 ===============================================================
 
 	idClipModel
 
 ===============================================================
 */
 
 /*
 ================
 idClipModel::LoadModel
 ================
 */
 bool idClipModel::LoadModel( const char *name ) {
 	renderModelHandle = -1;
 	if ( traceModelIndex != -1 ) {
 		FreeTraceModel( traceModelIndex );
 		traceModelIndex = -1;
 	}
 	collisionModelHandle = collisionModelManager->LoadModel( name );
 	if ( collisionModelHandle ) {
 		collisionModelManager->GetModelBounds( collisionModelHandle, bounds );
 		collisionModelManager->GetModelContents( collisionModelHandle, contents );
 		return true;
 	} else {
 		bounds.Zero();
 		return false;
 	}
 }
 
 /*
 ================
 idClipModel::LoadModel
 ================
 */
 void idClipModel::LoadModel( const idTraceModel &trm, bool persistantThroughSave ) {
 	collisionModelHandle = 0;
 	renderModelHandle = -1;
 	if ( traceModelIndex != -1 ) {
 		FreeTraceModel( traceModelIndex );
 	}
 	traceModelIndex = AllocTraceModel( trm, persistantThroughSave );
 	bounds = trm.bounds;
 }
 
 /*
 ================
 idClipModel::LoadModel
 ================
 */
 void idClipModel::LoadModel( const int renderModelHandle ) {
 	collisionModelHandle = 0;
 	this->renderModelHandle = renderModelHandle;
 	if ( renderModelHandle != -1 ) {
 		const renderEntity_t *renderEntity = gameRenderWorld->GetRenderEntity( renderModelHandle );
 		if ( renderEntity ) {
 			bounds = renderEntity->bounds;
 		}
 	}
 	if ( traceModelIndex != -1 ) {
 		FreeTraceModel( traceModelIndex );
 		traceModelIndex = -1;
 	}
 }
 
 /*
 ================
 idClipModel::Init
 ================
 */
 void idClipModel::Init() {
 	enabled = true;
 	entity = NULL;
 	id = 0;
 	owner = NULL;
 	origin.Zero();
 	axis.Identity();
 	bounds.Zero();
 	absBounds.Zero();
 	material = NULL;
 	contents = CONTENTS_BODY;
 	collisionModelHandle = 0;
 	renderModelHandle = -1;
 	traceModelIndex = -1;
 	clipLinks = NULL;
 	touchCount = -1;
 }
 
 /*
 ================
 idClipModel::idClipModel
 ================
 */
 idClipModel::idClipModel() {
 	Init();
 }
 
 /*
 ================
 idClipModel::idClipModel
 ================
 */
 idClipModel::idClipModel( const char *name ) {
 	Init();
 	LoadModel( name );
 }
 
 /*
 ================
 idClipModel::idClipModel
 ================
 */
 idClipModel::idClipModel( const idTraceModel &trm ) {
 	Init();
 	LoadModel( trm, true );
 }
 
 /*
 ================
 idClipModel::idClipModel
 ================
 */
 idClipModel::idClipModel( const idTraceModel &trm, bool persistantThroughSave ) {
 	Init();
 	LoadModel( trm, persistantThroughSave );
 }
 
 /*
 ================
 idClipModel::idClipModel
 ================
 */
 idClipModel::idClipModel( const int renderModelHandle ) {
 	Init();
 	contents = CONTENTS_RENDERMODEL;
 	LoadModel( renderModelHandle );
 }
 
 /*
 ================
 idClipModel::idClipModel
 ================
 */
 idClipModel::idClipModel( const idClipModel *model ) {
 	enabled = model->enabled;
 	entity = model->entity;
 	id = model->id;
 	owner = model->owner;
 	origin = model->origin;
 	axis = model->axis;
 	bounds = model->bounds;
 	absBounds = model->absBounds;
 	material = model->material;
 	contents = model->contents;
 	collisionModelHandle = model->collisionModelHandle;
 	traceModelIndex = -1;
 	if ( model->traceModelIndex != -1 ) {
 		LoadModel( *GetCachedTraceModel( model->traceModelIndex ) );
 	}
 	renderModelHandle = model->renderModelHandle;
 	clipLinks = NULL;
 	touchCount = -1;
 }
 
 /*
 ================
 idClipModel::~idClipModel
 ================
 */
 idClipModel::~idClipModel() {
 	// make sure the clip model is no longer linked
 	Unlink();
 	if ( traceModelIndex != -1 ) {
 		FreeTraceModel( traceModelIndex );
 	}
 }
 
 /*
 ================
 idClipModel::Save
 ================
 */
 void idClipModel::Save( idSaveGame *savefile ) const {
 	savefile->WriteBool( enabled );
 	savefile->WriteObject( entity );
 	savefile->WriteInt( id );
 	savefile->WriteObject( owner );
 	savefile->WriteVec3( origin );
 	savefile->WriteMat3( axis );
 	savefile->WriteBounds( bounds );
 	savefile->WriteBounds( absBounds );
 	savefile->WriteMaterial( material );
 	savefile->WriteInt( contents );
 	if ( collisionModelHandle >= 0 ) {
 		savefile->WriteString( collisionModelManager->GetModelName( collisionModelHandle ) );
 	} else {
 		savefile->WriteString( "" );
 	}
 	savefile->WriteInt( traceModelIndex );
 	savefile->WriteInt( renderModelHandle );
 	savefile->WriteBool( clipLinks != NULL );
 	savefile->WriteInt( touchCount );
 }
 
 /*
 ================
 idClipModel::Restore
 ================
 */
 void idClipModel::Restore( idRestoreGame *savefile ) {
 	idStr collisionModelName;
 	bool linked;
 
 	savefile->ReadBool( enabled );
 	savefile->ReadObject( reinterpret_cast<idClass *&>( entity ) );
 	savefile->ReadInt( id );
 	savefile->ReadObject( reinterpret_cast<idClass *&>( owner ) );
 	savefile->ReadVec3( origin );
 	savefile->ReadMat3( axis );
 	savefile->ReadBounds( bounds );
 	savefile->ReadBounds( absBounds );
 	savefile->ReadMaterial( material );
 	savefile->ReadInt( contents );
 	savefile->ReadString( collisionModelName );
 	if ( collisionModelName.Length() ) {
 		collisionModelHandle = collisionModelManager->LoadModel( collisionModelName );
 	} else {
 		collisionModelHandle = -1;
 	}
 	savefile->ReadInt( traceModelIndex );
 	if ( traceModelIndex >= 0 ) {
 		int realIndex = traceModelIndex & ~TRACE_MODEL_SAVED;
 		traceModelCache[realIndex]->refCount++;
 	}
 	savefile->ReadInt( renderModelHandle );
 	savefile->ReadBool( linked );
 	savefile->ReadInt( touchCount );
 
 	// the render model will be set when the clip model is linked
 	renderModelHandle = -1;
 	clipLinks = NULL;
 	touchCount = -1;
 
 	if ( linked ) {
 		Link( gameLocal.clip, entity, id, origin, axis, renderModelHandle );
 	}
 }
 
 /*
 ================
 idClipModel::SetPosition
 ================
 */
 void idClipModel::SetPosition( const idVec3 &newOrigin, const idMat3 &newAxis ) {
 	if ( clipLinks ) {
 		Unlink();	// unlink from old position
 	}
 	origin = newOrigin;
 	axis = newAxis;
 }
 
 /*
 ================
 idClipModel::Handle
 ================
 */
 cmHandle_t idClipModel::Handle() const {
 	assert( renderModelHandle == -1 );
 	if ( collisionModelHandle ) {
 		return collisionModelHandle;
 	} else if ( traceModelIndex != -1 ) {
 		return collisionModelManager->SetupTrmModel( *GetCachedTraceModel( traceModelIndex ), material );
 	} else {
 		// this happens in multiplayer on the combat models
 		gameLocal.Warning( "idClipModel::Handle: clip model %d on '%s' (%x) is not a collision or trace model", id, entity->name.c_str(), entity->entityNumber );
 		return 0;
 	}
 }
 
 /*
 ================
 idClipModel::GetMassProperties
 ================
 */
 void idClipModel::GetMassProperties( const float density, float &mass, idVec3 &centerOfMass, idMat3 &inertiaTensor ) const {
 	if ( traceModelIndex == -1 ) {
 		gameLocal.Error( "idClipModel::GetMassProperties: clip model %d on '%s' is not a trace model\n", id, entity->name.c_str() );
 	}
 
 	trmCache_t *entry = GetTraceModelEntry( traceModelIndex ); //traceModelCache[traceModelIndex];
 	mass = entry->volume * density;
 	centerOfMass = entry->centerOfMass;
 	inertiaTensor = density * entry->inertiaTensor;
 }
 
 /*
 ===============
 idClipModel::Unlink
 ===============
 */
 void idClipModel::Unlink() {
 	clipLink_t *link;
 
 	for ( link = clipLinks; link; link = clipLinks ) {
 		clipLinks = link->nextLink;
 		if ( link->prevInSector ) {
 			link->prevInSector->nextInSector = link->nextInSector;
 		} else {
 			link->sector->clipLinks = link->nextInSector;
 		}
 		if ( link->nextInSector ) {
 			link->nextInSector->prevInSector = link->prevInSector;
 		}
 		clipLinkAllocator.Free( link );
 	}
 }
 
 /*
 ===============
 idClipModel::Link_r
 ===============
 */
 void idClipModel::Link_r( struct clipSector_s *node ) {
 	clipLink_t *link;
 
 	while( node->axis != -1 ) {
 		if ( absBounds[0][node->axis] > node->dist ) {
 			node = node->children[0];
 		} else if ( absBounds[1][node->axis] < node->dist ) {
 			node = node->children[1];
 		} else {
 			Link_r( node->children[0] );
 			node = node->children[1];
 		}
 	}
 
 	link = clipLinkAllocator.Alloc();
 	link->clipModel = this;
 	link->sector = node;
 	link->nextInSector = node->clipLinks;
 	link->prevInSector = NULL;
 	if ( node->clipLinks ) {
 		node->clipLinks->prevInSector = link;
 	}
 	node->clipLinks = link;
 	link->nextLink = clipLinks;
 	clipLinks = link;
 }
 
 /*
 ===============
 idClipModel::Link
 ===============
 */
 void idClipModel::Link( idClip &clp ) {
 
 	assert( idClipModel::entity );
 	if ( !idClipModel::entity ) {
 		return;
 	}
 
 	if ( clipLinks ) {
 		Unlink();	// unlink from old position
 	}
 
 	if ( bounds.IsCleared() ) {
 		return;
 	}
 
 	// set the abs box
 	if ( axis.IsRotated() ) {
 		// expand for rotation
 		absBounds.FromTransformedBounds( bounds, origin, axis );
 	} else {
 		// normal
 		absBounds[0] = bounds[0] + origin;
 		absBounds[1] = bounds[1] + origin;
 	}
 
 	// because movement is clipped an epsilon away from an actual edge,
 	// we must fully check even when bounding boxes don't quite touch
 	absBounds[0] -= vec3_boxEpsilon;
 	absBounds[1] += vec3_boxEpsilon;
 
 	Link_r( clp.clipSectors );
 }
 
 /*
 ===============
 idClipModel::Link
 ===============
 */
 void idClipModel::Link( idClip &clp, idEntity *ent, int newId, const idVec3 &newOrigin, const idMat3 &newAxis, int renderModelHandle ) {
 
 	this->entity = ent;
 	this->id = newId;
 	this->origin = newOrigin;
 	this->axis = newAxis;
 	if ( renderModelHandle != -1 ) {
 		this->renderModelHandle = renderModelHandle;
 		const renderEntity_t *renderEntity = gameRenderWorld->GetRenderEntity( renderModelHandle );
 		if ( renderEntity ) {
 			this->bounds = renderEntity->bounds;
 		}
 	}
 	this->Link( clp );
 }
 
 /*
 ============
 idClipModel::CheckModel
 ============
 */
 cmHandle_t idClipModel::CheckModel( const char *name ) {
 	return collisionModelManager->LoadModel( name );
 }
 
 
 /*
 ===============================================================
 
 	idClip
 
 ===============================================================
 */
 
 /*
 ===============
 idClip::idClip
 ===============
 */
 idClip::idClip() {
 	numClipSectors = 0;
 	clipSectors = NULL;
 	worldBounds.Zero();
 	numRotations = numTranslations = numMotions = numRenderModelTraces = numContents = numContacts = 0;
 }
 
 /*
 ===============
 idClip::CreateClipSectors_r
 
 Builds a uniformly subdivided tree for the given world size
 ===============
 */
 clipSector_t *idClip::CreateClipSectors_r( const int depth, const idBounds &bounds, idVec3 &maxSector ) {
 	int				i;
 	clipSector_t	*anode;
 	idVec3			size;
 	idBounds		front, back;
 
 	anode = &clipSectors[idClip::numClipSectors];
 	idClip::numClipSectors++;
 
 	if ( depth == MAX_SECTOR_DEPTH ) {
 		anode->axis = -1;
 		anode->children[0] = anode->children[1] = NULL;
 
 		for ( i = 0; i < 3; i++ ) {
 			if ( bounds[1][i] - bounds[0][i] > maxSector[i] ) {
 				maxSector[i] = bounds[1][i] - bounds[0][i];
 			}
 		}
 		return anode;
 	}
 
 	size = bounds[1] - bounds[0];
 	if ( size[0] >= size[1] && size[0] >= size[2] ) {
 		anode->axis = 0;
 	} else if ( size[1] >= size[0] && size[1] >= size[2] ) {
 		anode->axis = 1;
 	} else {
 		anode->axis = 2;
 	}
 
 	anode->dist = 0.5f * ( bounds[1][anode->axis] + bounds[0][anode->axis] );
 
 	front = bounds;
 	back = bounds;
 	
 	front[0][anode->axis] = back[1][anode->axis] = anode->dist;
 	
 	anode->children[0] = CreateClipSectors_r( depth+1, front, maxSector );
 	anode->children[1] = CreateClipSectors_r( depth+1, back, maxSector );
 
 	return anode;
 }
 
 /*
 ===============
 idClip::Init
 ===============
 */
 void idClip::Init() {
 	cmHandle_t h;
 	idVec3 size, maxSector = vec3_origin;
 
 	// clear clip sectors
 	clipSectors = new (TAG_PHYSICS_CLIP) clipSector_t[MAX_SECTORS];
 	memset( clipSectors, 0, MAX_SECTORS * sizeof( clipSector_t ) );
 	numClipSectors = 0;
 	touchCount = -1;
 	// get world map bounds
 	h = collisionModelManager->LoadModel( "worldMap" );
 	collisionModelManager->GetModelBounds( h, worldBounds );
 	// create world sectors
 	CreateClipSectors_r( 0, worldBounds, maxSector );
 
 	size = worldBounds[1] - worldBounds[0];
 	gameLocal.Printf( "map bounds are (%1.1f, %1.1f, %1.1f)\n", size[0], size[1], size[2] );
 	gameLocal.Printf( "max clip sector is (%1.1f, %1.1f, %1.1f)\n", maxSector[0], maxSector[1], maxSector[2] );
 
 	// initialize a default clip model
 	defaultClipModel.LoadModel( idTraceModel( idBounds( idVec3( 0, 0, 0 ) ).Expand( 8 ) ) );
 
 	// set counters to zero
 	numRotations = numTranslations = numMotions = numRenderModelTraces = numContents = numContacts = 0;
 }
 
 /*
 ===============
 idClip::Shutdown
 ===============
 */
 void idClip::Shutdown() {
 	delete[] clipSectors;
 	clipSectors = NULL;
 
 	// free the trace model used for the temporaryClipModel
 	if ( temporaryClipModel.traceModelIndex != -1 ) {
 		idClipModel::FreeTraceModel( temporaryClipModel.traceModelIndex );
 		temporaryClipModel.traceModelIndex = -1;
 	}
 
 	// free the trace model used for the defaultClipModel
 	if ( defaultClipModel.traceModelIndex != -1 ) {
 		idClipModel::FreeTraceModel( defaultClipModel.traceModelIndex );
 		defaultClipModel.traceModelIndex = -1;
 	}
 
 	clipLinkAllocator.Shutdown();
 }
 
 /*
 ====================
 idClip::ClipModelsTouchingBounds_r
 ====================
 */
 typedef struct listParms_s {
 	idBounds		bounds;
 	int				contentMask;
 	idClipModel	**	list;
 	int				count;
 	int				maxCount;
 } listParms_t;
 
 void idClip::ClipModelsTouchingBounds_r( const struct clipSector_s *node, listParms_t &parms ) const {
 
 	while( node->axis != -1 ) {
 		if ( parms.bounds[0][node->axis] > node->dist ) {
 			node = node->children[0];
 		} else if ( parms.bounds[1][node->axis] < node->dist ) {
 			node = node->children[1];
 		} else {
 			ClipModelsTouchingBounds_r( node->children[0], parms );
 			node = node->children[1];
 		}
 	}
 
 	for ( clipLink_t *link = node->clipLinks; link; link = link->nextInSector ) {
 		idClipModel	*check = link->clipModel;
 
 		// if the clip model is enabled
 		if ( !check->enabled ) {
 			continue;
 		}
 
 		// avoid duplicates in the list
 		if ( check->touchCount == touchCount ) {
 			continue;
 		}
 
 		// if the clip model does not have any contents we are looking for
 		if ( !( check->contents & parms.contentMask ) ) {
 			continue;
 		}
 
 		// if the bounds really do overlap
 		if (	check->absBounds[0][0] > parms.bounds[1][0] ||
 				check->absBounds[1][0] < parms.bounds[0][0] ||
 				check->absBounds[0][1] > parms.bounds[1][1] ||
 				check->absBounds[1][1] < parms.bounds[0][1] ||
 				check->absBounds[0][2] > parms.bounds[1][2] ||
 				check->absBounds[1][2] < parms.bounds[0][2] ) {
 			continue;
 		}
 
 		if ( parms.count >= parms.maxCount ) {
 			gameLocal.Warning( "idClip::ClipModelsTouchingBounds_r: max count" );
 			return;
 		}
 
 		check->touchCount = touchCount;
 		parms.list[parms.count] = check;
 		parms.count++;
 	}
 }
 
 /*
 ================
 idClip::ClipModelsTouchingBounds
 ================
 */
 int idClip::ClipModelsTouchingBounds( const idBounds &bounds, int contentMask, idClipModel **clipModelList, int maxCount ) const {
 	listParms_t parms;
 
 	if (	bounds[0][0] > bounds[1][0] ||
 			bounds[0][1] > bounds[1][1] ||
 			bounds[0][2] > bounds[1][2] ) {
 		// we should not go through the tree for degenerate or backwards bounds
 		assert( false );
 		return 0;
 	}
 
 	parms.bounds[0] = bounds[0] - vec3_boxEpsilon;
 	parms.bounds[1] = bounds[1] + vec3_boxEpsilon;
 	parms.contentMask = contentMask;
 	parms.list = clipModelList;
 	parms.count = 0;
 	parms.maxCount = maxCount;
 
 	touchCount++;
 	ClipModelsTouchingBounds_r( clipSectors, parms );
 
 	return parms.count;
 }
 
 /*
 ================
 idClip::EntitiesTouchingBounds
 ================
 */
 int idClip::EntitiesTouchingBounds( const idBounds &bounds, int contentMask, idEntity **entityList, int maxCount ) const {
 	idClipModel *clipModelList[MAX_GENTITIES];
 	int i, j, count, entCount;
 
 	count = idClip::ClipModelsTouchingBounds( bounds, contentMask, clipModelList, MAX_GENTITIES );
 	entCount = 0;
 	for ( i = 0; i < count; i++ ) {
 		// entity could already be in the list because an entity can use multiple clip models
 		for ( j = 0; j < entCount; j++ ) {
 			if ( entityList[j] == clipModelList[i]->entity ) {
 				break;
 			}
 		}
 		if ( j >= entCount ) {
 			if ( entCount >= maxCount ) {
 				gameLocal.Warning( "idClip::EntitiesTouchingBounds: max count" );
 				return entCount;
 			}
 			entityList[entCount] = clipModelList[i]->entity;
 			entCount++;
 		}
 	}
 
 	return entCount;
 }
 
 /*
 ====================
 idClip::GetTraceClipModels
 
   an ent will be excluded from testing if:
   cm->entity == passEntity ( don't clip against the pass entity )
   cm->entity == passOwner ( missiles don't clip with owner )
   cm->owner == passEntity ( don't interact with your own missiles )
   cm->owner == passOwner ( don't interact with other missiles from same owner )
 ====================
 */
 int idClip::GetTraceClipModels( const idBounds &bounds, int contentMask, const idEntity *passEntity, idClipModel **clipModelList ) const {
 	int i, num;
 	idClipModel	*cm;
 	idEntity *passOwner;
 
 	num = ClipModelsTouchingBounds( bounds, contentMask, clipModelList, MAX_GENTITIES );
 
 	if ( !passEntity ) {
 		return num;
 	}
 
 	if ( passEntity->GetPhysics()->GetNumClipModels() > 0 ) {
 		passOwner = passEntity->GetPhysics()->GetClipModel()->GetOwner();
 	} else {
 		passOwner = NULL;
 	}
 
 	for ( i = 0; i < num; i++ ) {
 
 		cm = clipModelList[i];
 
 		// check if we should ignore this entity
 		if ( cm->entity == passEntity ) {
 			clipModelList[i] = NULL;			// don't clip against the pass entity
 		} else if ( cm->entity == passOwner ) {
 			clipModelList[i] = NULL;			// missiles don't clip with their owner
 		} else if ( cm->owner ) {
 			if ( cm->owner == passEntity ) {
 				clipModelList[i] = NULL;		// don't clip against own missiles
 			} else if ( cm->owner == passOwner ) {
 				clipModelList[i] = NULL;		// don't clip against other missiles from same owner
 			}
 		}
 	}
 
 	return num;
 }
 
 /*
 ============
 idClip::TraceRenderModel
 ============
 */
 void idClip::TraceRenderModel( trace_t &trace, const idVec3 &start, const idVec3 &end, const float radius, const idMat3 &axis, idClipModel *touch ) const {
 	trace.fraction = 1.0f;
 
 	// if the trace is passing through the bounds
 	if ( touch->absBounds.Expand( radius ).LineIntersection( start, end ) ) {
 		modelTrace_t modelTrace;
 
 		// test with exact render model and modify trace_t structure accordingly
 		if ( gameRenderWorld->ModelTrace( modelTrace, touch->renderModelHandle, start, end, radius ) ) {
 			trace.fraction = modelTrace.fraction;
 			trace.endAxis = axis;
 			trace.endpos = modelTrace.point;
 			trace.c.normal = modelTrace.normal;
 			trace.c.dist = modelTrace.point * modelTrace.normal;
 			trace.c.point = modelTrace.point;
 			trace.c.type = CONTACT_TRMVERTEX;
 			trace.c.modelFeature = 0;
 			trace.c.trmFeature = 0;
 			trace.c.contents = modelTrace.material->GetContentFlags();
 			trace.c.material = modelTrace.material;
 			// NOTE: trace.c.id will be the joint number
 			touch->id = JOINT_HANDLE_TO_CLIPMODEL_ID( modelTrace.jointNumber );
 		}
 	}
 }
 
 /*
 ============
 idClip::TraceModelForClipModel
 ============
 */
 const idTraceModel *idClip::TraceModelForClipModel( const idClipModel *mdl ) const {
 	if ( !mdl ) {
 		return NULL;
 	} else {
 		if ( !mdl->IsTraceModel() ) {
 			if ( mdl->GetEntity() ) {
 				gameLocal.Error( "TraceModelForClipModel: clip model %d on '%s' is not a trace model\n", mdl->GetId(), mdl->GetEntity()->name.c_str() );
 			} else {
 				gameLocal.Error( "TraceModelForClipModel: clip model %d is not a trace model\n", mdl->GetId() );
 			}
 		}
 		return idClipModel::GetCachedTraceModel( mdl->traceModelIndex );
 	}
 }
 
 /*
 ============
 idClip::TestHugeTranslation
 ============
 */
 ID_INLINE bool TestHugeTranslation( trace_t &results, const idClipModel *mdl, const idVec3 &start, const idVec3 &end, const idMat3 &trmAxis ) {
 	if ( mdl != NULL && ( end - start ).LengthSqr() > Square( CM_MAX_TRACE_DIST ) ) {
 #ifndef CTF
 		// May be important: This occurs in CTF when a player connects and spawns
 		// in the PVS of a player that has a flag that is spawning the idMoveableItem
 		// "nuggets".  The error seems benign and the assert was getting in the way
 		// of testing.  
 		assert( 0 );
 #endif
 
 		results.fraction = 0.0f;
 		results.endpos = start;
 		results.endAxis = trmAxis;
 		memset( &results.c, 0, sizeof( results.c ) );
 		results.c.point = start;
 
 		if ( mdl->GetEntity() ) {
 			gameLocal.Printf( "huge translation for clip model %d on entity %d '%s'\n", mdl->GetId(), mdl->GetEntity()->entityNumber, mdl->GetEntity()->GetName() );
 		} else {
 			gameLocal.Printf( "huge translation for clip model %d\n", mdl->GetId() );
 		}
 		return true;
 	}
 	return false;
 }
 
 /*
 ============
 idClip::TranslationEntities
 ============
 */
 void idClip::TranslationEntities( trace_t &results, const idVec3 &start, const idVec3 &end,
 						const idClipModel *mdl, const idMat3 &trmAxis, int contentMask, const idEntity *passEntity ) {
 	int i, num;
 	idClipModel *touch, *clipModelList[MAX_GENTITIES];
 	idBounds traceBounds;
 	float radius;
 	trace_t trace;
 	const idTraceModel *trm;
 
 	if ( TestHugeTranslation( results, mdl, start, end, trmAxis ) ) {
 		return;
 	}
 
 	trm = TraceModelForClipModel( mdl );
 
 	results.fraction = 1.0f;
 	results.endpos = end;
 	results.endAxis = trmAxis;
 
 	if ( !trm ) {
 		traceBounds.FromPointTranslation( start, end - start );
 		radius = 0.0f;
 	} else {
 		traceBounds.FromBoundsTranslation( trm->bounds, start, trmAxis, end - start );
 		radius = trm->bounds.GetRadius();
 	}
 
 	num = GetTraceClipModels( traceBounds, contentMask, passEntity, clipModelList );
 
 	for ( i = 0; i < num; i++ ) {
 		touch = clipModelList[i];
 
 		if ( !touch ) {
 			continue;
 		}
 
 		if ( touch->renderModelHandle != -1 ) {
 			idClip::numRenderModelTraces++;
 			TraceRenderModel( trace, start, end, radius, trmAxis, touch );
 		} else {
 			idClip::numTranslations++;
 			collisionModelManager->Translation( &trace, start, end, trm, trmAxis, contentMask,
 									touch->Handle(), touch->origin, touch->axis );
 		}
 
 		if ( trace.fraction < results.fraction ) {
 			results = trace;
 			results.c.entityNum = touch->entity->entityNumber;
 			results.c.id = touch->id;
 			if ( results.fraction == 0.0f ) {
 				break;
 			}
 		}
 	}
 }
 
 /*
 ============
 idClip::Translation
 ============
 */
 bool idClip::Translation( trace_t &results, const idVec3 &start, const idVec3 &end,
 						const idClipModel *mdl, const idMat3 &trmAxis, int contentMask, const idEntity *passEntity ) {
 	int i, num;
 	idClipModel *touch, *clipModelList[MAX_GENTITIES];
 	idBounds traceBounds;
 	float radius;
 	trace_t trace;
 	const idTraceModel *trm;
 
 	if ( TestHugeTranslation( results, mdl, start, end, trmAxis ) ) {
 		return true;
 	}
 
 	trm = TraceModelForClipModel( mdl );
 
 	if ( !passEntity || passEntity->entityNumber != ENTITYNUM_WORLD ) {
 		// test world
 		idClip::numTranslations++;
 		collisionModelManager->Translation( &results, start, end, trm, trmAxis, contentMask, 0, vec3_origin, mat3_default );
 		results.c.entityNum = results.fraction != 1.0f ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
 		if ( results.fraction == 0.0f ) {
 			return true;		// blocked immediately by the world
 		}
 	} else {
 		memset( &results, 0, sizeof( results ) );
 		results.fraction = 1.0f;
 		results.endpos = end;
 		results.endAxis = trmAxis;
 	}
 
 	if ( !trm ) {
 		traceBounds.FromPointTranslation( start, results.endpos - start );
 		radius = 0.0f;
 	} else {
 		traceBounds.FromBoundsTranslation( trm->bounds, start, trmAxis, results.endpos - start );
 		radius = trm->bounds.GetRadius();
 	}
 
 	num = GetTraceClipModels( traceBounds, contentMask, passEntity, clipModelList );
 
 	for ( i = 0; i < num; i++ ) {
 		touch = clipModelList[i];
 
 		if ( !touch ) {
 			continue;
 		}
 
 		if ( touch->renderModelHandle != -1 ) {
 			idClip::numRenderModelTraces++;
 			TraceRenderModel( trace, start, end, radius, trmAxis, touch );
 		} else {
 			idClip::numTranslations++;
 			collisionModelManager->Translation( &trace, start, end, trm, trmAxis, contentMask,
 									touch->Handle(), touch->origin, touch->axis );
 		}
 
 		if ( trace.fraction < results.fraction ) {
 			results = trace;
 			results.c.entityNum = touch->entity->entityNumber;
 			results.c.id = touch->id;
 			if ( results.fraction == 0.0f ) {
 				break;
 			}
 		}
 	}
 
 	return ( results.fraction < 1.0f );
 }
 
 /*
 ============
 idClip::Rotation
 ============
 */
 bool idClip::Rotation( trace_t &results, const idVec3 &start, const idRotation &rotation,
 					const idClipModel *mdl, const idMat3 &trmAxis, int contentMask, const idEntity *passEntity ) {
 	int i, num;
 	idClipModel *touch, *clipModelList[MAX_GENTITIES];
 	idBounds traceBounds;
 	trace_t trace;
 	const idTraceModel *trm;
 
 	trm = TraceModelForClipModel( mdl );
 
 	if ( !passEntity || passEntity->entityNumber != ENTITYNUM_WORLD ) {
 		// test world
 		idClip::numRotations++;
 		collisionModelManager->Rotation( &results, start, rotation, trm, trmAxis, contentMask, 0, vec3_origin, mat3_default );
 		results.c.entityNum = results.fraction != 1.0f ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
 		if ( results.fraction == 0.0f ) {
 			return true;		// blocked immediately by the world
 		}
 	} else {
 		memset( &results, 0, sizeof( results ) );
 		results.fraction = 1.0f;
 		results.endpos = start;
 		results.endAxis = trmAxis * rotation.ToMat3();
 	}
 
 	if ( !trm ) {
 		traceBounds.FromPointRotation( start, rotation );
 	} else {
 		traceBounds.FromBoundsRotation( trm->bounds, start, trmAxis, rotation );
 	}
 
 	num = GetTraceClipModels( traceBounds, contentMask, passEntity, clipModelList );
 
 	for ( i = 0; i < num; i++ ) {
 		touch = clipModelList[i];
 
 		if ( !touch ) {
 			continue;
 		}
 
 		// no rotational collision with render models
 		if ( touch->renderModelHandle != -1 ) {
 			continue;
 		}
 
 		idClip::numRotations++;
 		collisionModelManager->Rotation( &trace, start, rotation, trm, trmAxis, contentMask,
 							touch->Handle(), touch->origin, touch->axis );
 
 		if ( trace.fraction < results.fraction ) {
 			results = trace;
 			results.c.entityNum = touch->entity->entityNumber;
 			results.c.id = touch->id;
 			if ( results.fraction == 0.0f ) {
 				break;
 			}
 		}
 	}
 
 	return ( results.fraction < 1.0f );
 }
 
 /*
 ============
 idClip::Motion
 ============
 */
 bool idClip::Motion( trace_t &results, const idVec3 &start, const idVec3 &end, const idRotation &rotation,
 					const idClipModel *mdl, const idMat3 &trmAxis, int contentMask, const idEntity *passEntity ) {
 	int i, num;
 	idClipModel *touch, *clipModelList[MAX_GENTITIES];
 	idVec3 dir, endPosition;
 	idBounds traceBounds;
 	float radius;
 	trace_t translationalTrace, rotationalTrace, trace;
 	idRotation endRotation;
 	const idTraceModel *trm;
 
 	assert( rotation.GetOrigin() == start );
 
 	if ( TestHugeTranslation( results, mdl, start, end, trmAxis ) ) {
 		return true;
 	}
 
 	if ( mdl != NULL && rotation.GetAngle() != 0.0f && rotation.GetVec() != vec3_origin ) {
 		// if no translation
 		if ( start == end ) {
 			// pure rotation
 			return Rotation( results, start, rotation, mdl, trmAxis, contentMask, passEntity );
 		}
 	} else if ( start != end ) {
 		// pure translation
 		return Translation( results, start, end, mdl, trmAxis, contentMask, passEntity );
 	} else {
 		// no motion
 		results.fraction = 1.0f;
 		results.endpos = start;
 		results.endAxis = trmAxis;
 		return false;
 	}
 
 	trm = TraceModelForClipModel( mdl );
 
 	radius = trm->bounds.GetRadius();
 
 	if ( !passEntity || passEntity->entityNumber != ENTITYNUM_WORLD ) {
 		// translational collision with world
 		idClip::numTranslations++;
 		collisionModelManager->Translation( &translationalTrace, start, end, trm, trmAxis, contentMask, 0, vec3_origin, mat3_default );
 		translationalTrace.c.entityNum = translationalTrace.fraction != 1.0f ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
 	} else {
 		memset( &translationalTrace, 0, sizeof( translationalTrace ) );
 		translationalTrace.fraction = 1.0f;
 		translationalTrace.endpos = end;
 		translationalTrace.endAxis = trmAxis;
 	}
 
 	if ( translationalTrace.fraction != 0.0f ) {
 
 		traceBounds.FromBoundsRotation( trm->bounds, start, trmAxis, rotation );
 		dir = translationalTrace.endpos - start;
 		for ( i = 0; i < 3; i++ ) {
 			if ( dir[i] < 0.0f ) {
 				traceBounds[0][i] += dir[i];
 			}
 			else {
 				traceBounds[1][i] += dir[i];
 			}
 		}
 
 		num = GetTraceClipModels( traceBounds, contentMask, passEntity, clipModelList );
 
 		for ( i = 0; i < num; i++ ) {
 			touch = clipModelList[i];
 
 			if ( !touch ) {
 				continue;
 			}
 
 			if ( touch->renderModelHandle != -1 ) {
 				idClip::numRenderModelTraces++;
 				TraceRenderModel( trace, start, end, radius, trmAxis, touch );
 			} else {
 				idClip::numTranslations++;
 				collisionModelManager->Translation( &trace, start, end, trm, trmAxis, contentMask,
 										touch->Handle(), touch->origin, touch->axis );
 			}
 
 			if ( trace.fraction < translationalTrace.fraction ) {
 				translationalTrace = trace;
 				translationalTrace.c.entityNum = touch->entity->entityNumber;
 				translationalTrace.c.id = touch->id;
 				if ( translationalTrace.fraction == 0.0f ) {
 					break;
 				}
 			}
 		}
 	} else {
 		num = -1;
 	}
 
 	endPosition = translationalTrace.endpos;
 	endRotation = rotation;
 	endRotation.SetOrigin( endPosition );
 
 	if ( !passEntity || passEntity->entityNumber != ENTITYNUM_WORLD ) {
 		// rotational collision with world
 		idClip::numRotations++;
 		collisionModelManager->Rotation( &rotationalTrace, endPosition, endRotation, trm, trmAxis, contentMask, 0, vec3_origin, mat3_default );
 		rotationalTrace.c.entityNum = rotationalTrace.fraction != 1.0f ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
 	} else {
 		memset( &rotationalTrace, 0, sizeof( rotationalTrace ) );
 		rotationalTrace.fraction = 1.0f;
 		rotationalTrace.endpos = endPosition;
 		rotationalTrace.endAxis = trmAxis * rotation.ToMat3();
 	}
 
 	if ( rotationalTrace.fraction != 0.0f ) {
 
 		if ( num == -1 ) {
 			traceBounds.FromBoundsRotation( trm->bounds, endPosition, trmAxis, endRotation );
 			num = GetTraceClipModels( traceBounds, contentMask, passEntity, clipModelList );
 		}
 
 		for ( i = 0; i < num; i++ ) {
 			touch = clipModelList[i];
 
 			if ( !touch ) {
 				continue;
 			}
 
 			// no rotational collision detection with render models
 			if ( touch->renderModelHandle != -1 ) {
 				continue;
 			}
 
 			idClip::numRotations++;
 			collisionModelManager->Rotation( &trace, endPosition, endRotation, trm, trmAxis, contentMask,
 								touch->Handle(), touch->origin, touch->axis );
 
 			if ( trace.fraction < rotationalTrace.fraction ) {
 				rotationalTrace = trace;
 				rotationalTrace.c.entityNum = touch->entity->entityNumber;
 				rotationalTrace.c.id = touch->id;
 				if ( rotationalTrace.fraction == 0.0f ) {
 					break;
 				}
 			}
 		}
 	}
 
 	if ( rotationalTrace.fraction < 1.0f ) {
 		results = rotationalTrace;
 	} else {
 		results = translationalTrace;
 		results.endAxis = rotationalTrace.endAxis;
 	}
 
 	results.fraction = Max( translationalTrace.fraction, rotationalTrace.fraction );
 
 	return ( translationalTrace.fraction < 1.0f || rotationalTrace.fraction < 1.0f );
 }
 
 /*
 ============
 idClip::Contacts
 ============
 */
 int idClip::Contacts( contactInfo_t *contacts, const int maxContacts, const idVec3 &start, const idVec6 &dir, const float depth,
 					 const idClipModel *mdl, const idMat3 &trmAxis, int contentMask, const idEntity *passEntity ) {
 	int i, j, num, n, numContacts;
 	idClipModel *touch, *clipModelList[MAX_GENTITIES];
 	idBounds traceBounds;
 	const idTraceModel *trm;
 
 	trm = TraceModelForClipModel( mdl );
 
 	if ( !passEntity || passEntity->entityNumber != ENTITYNUM_WORLD ) {
 		// test world
 		idClip::numContacts++;
 		numContacts = collisionModelManager->Contacts( contacts, maxContacts, start, dir, depth, trm, trmAxis, contentMask, 0, vec3_origin, mat3_default );
 	} else {
 		numContacts = 0;
 	}
 
 	for ( i = 0; i < numContacts; i++ ) {
 		contacts[i].entityNum = ENTITYNUM_WORLD;
 		contacts[i].id = 0;
 	}
 
 	if ( numContacts >= maxContacts ) {
 		return numContacts;
 	}
 
 	if ( !trm ) {
 		traceBounds = idBounds( start ).Expand( depth );
 	} else {
 		traceBounds.FromTransformedBounds( trm->bounds, start, trmAxis );
 		traceBounds.ExpandSelf( depth );
 	}
 
 	num = GetTraceClipModels( traceBounds, contentMask, passEntity, clipModelList );
 
 	for ( i = 0; i < num; i++ ) {
 		touch = clipModelList[i];
 
 		if ( !touch ) {
 			continue;
 		}
 
 		// no contacts with render models
 		if ( touch->renderModelHandle != -1 ) {
 			continue;
 		}
 
 		idClip::numContacts++;
 		n = collisionModelManager->Contacts( contacts + numContacts, maxContacts - numContacts,
 								start, dir, depth, trm, trmAxis, contentMask,
 									touch->Handle(), touch->origin, touch->axis );
 
 		for ( j = 0; j < n; j++ ) {
 			contacts[numContacts].entityNum = touch->entity->entityNumber;
 			contacts[numContacts].id = touch->id;
 			numContacts++;
 		}
 
 		if ( numContacts >= maxContacts ) {
 			break;
 		}
 	}
 
 	return numContacts;
 }
 
 /*
 ============
 idClip::Contents
 ============
 */
 int idClip::Contents( const idVec3 &start, const idClipModel *mdl, const idMat3 &trmAxis, int contentMask, const idEntity *passEntity ) {
 	int i, num, contents;
 	idClipModel *touch, *clipModelList[MAX_GENTITIES];
 	idBounds traceBounds;
 	const idTraceModel *trm;
 
 	trm = TraceModelForClipModel( mdl );
 
 	if ( !passEntity || passEntity->entityNumber != ENTITYNUM_WORLD ) {
 		// test world
 		idClip::numContents++;
 		contents = collisionModelManager->Contents( start, trm, trmAxis, contentMask, 0, vec3_origin, mat3_default );
 	} else {
 		contents = 0;
 	}
 
 	if ( !trm ) {
 		traceBounds[0] = start;
 		traceBounds[1] = start;
 	} else if ( trmAxis.IsRotated() ) {
 		traceBounds.FromTransformedBounds( trm->bounds, start, trmAxis );
 	} else {
 		traceBounds[0] = trm->bounds[0] + start;
 		traceBounds[1] = trm->bounds[1] + start;
 	}
 
 	num = GetTraceClipModels( traceBounds, -1, passEntity, clipModelList );
 
 	for ( i = 0; i < num; i++ ) {
 		touch = clipModelList[i];
 
 		if ( !touch ) {
 			continue;
 		}
 
 		// no contents test with render models
 		if ( touch->renderModelHandle != -1 ) {
 			continue;
 		}
 
 		// if the entity does not have any contents we are looking for
 		if ( ( touch->contents & contentMask ) == 0 ) {
 			continue;
 		}
 
 		// if the entity has no new contents flags
 		if ( ( touch->contents & contents ) == touch->contents ) {
 			continue;
 		}
 
 		idClip::numContents++;
 		if ( collisionModelManager->Contents( start, trm, trmAxis, contentMask, touch->Handle(), touch->origin, touch->axis ) ) {
 			contents |= ( touch->contents & contentMask );
 		}
 	}
 
 	return contents;
 }
 
 /*
 ============
 idClip::TranslationModel
 ============
 */
 void idClip::TranslationModel( trace_t &results, const idVec3 &start, const idVec3 &end,
 					const idClipModel *mdl, const idMat3 &trmAxis, int contentMask,
 					cmHandle_t model, const idVec3 &modelOrigin, const idMat3 &modelAxis ) {
 	const idTraceModel *trm = TraceModelForClipModel( mdl );
 	idClip::numTranslations++;
 	collisionModelManager->Translation( &results, start, end, trm, trmAxis, contentMask, model, modelOrigin, modelAxis );
 }
 
 /*
 ============
 idClip::RotationModel
 ============
 */
 void idClip::RotationModel( trace_t &results, const idVec3 &start, const idRotation &rotation,
 					const idClipModel *mdl, const idMat3 &trmAxis, int contentMask,
 					cmHandle_t model, const idVec3 &modelOrigin, const idMat3 &modelAxis ) {
 	const idTraceModel *trm = TraceModelForClipModel( mdl );
 	idClip::numRotations++;
 	collisionModelManager->Rotation( &results, start, rotation, trm, trmAxis, contentMask, model, modelOrigin, modelAxis );
 }
 
 /*
 ============
 idClip::ContactsModel
 ============
 */
 int idClip::ContactsModel( contactInfo_t *contacts, const int maxContacts, const idVec3 &start, const idVec6 &dir, const float depth,
 					const idClipModel *mdl, const idMat3 &trmAxis, int contentMask,
 					cmHandle_t model, const idVec3 &modelOrigin, const idMat3 &modelAxis ) {
 	const idTraceModel *trm = TraceModelForClipModel( mdl );
 	idClip::numContacts++;
 	return collisionModelManager->Contacts( contacts, maxContacts, start, dir, depth, trm, trmAxis, contentMask, model, modelOrigin, modelAxis );
 }
 
 /*
 ============
 idClip::ContentsModel
 ============
 */
 int idClip::ContentsModel( const idVec3 &start,
 					const idClipModel *mdl, const idMat3 &trmAxis, int contentMask,
 					cmHandle_t model, const idVec3 &modelOrigin, const idMat3 &modelAxis ) {
 	const idTraceModel *trm = TraceModelForClipModel( mdl );
 	idClip::numContents++;
 	return collisionModelManager->Contents( start, trm, trmAxis, contentMask, model, modelOrigin, modelAxis );
 }
 
 /*
 ============
 idClip::GetModelContactFeature
 ============
 */
 bool idClip::GetModelContactFeature( const contactInfo_t &contact, const idClipModel *clipModel, idFixedWinding &winding ) const {
 	int i;
 	cmHandle_t handle;
 	idVec3 start, end;
 
 	handle = -1;
 	winding.Clear();
 
 	if ( clipModel == NULL ) {
 		handle = 0;
 	} else {
 		if ( clipModel->renderModelHandle != -1 ) {
 			winding += contact.point;
 			return true;
 		} else if ( clipModel->traceModelIndex != -1 ) {
 			handle = collisionModelManager->SetupTrmModel( *idClipModel::GetCachedTraceModel( clipModel->traceModelIndex ), clipModel->material );
 		} else {
 			handle = clipModel->collisionModelHandle;
 		}
 	}
 
 	// if contact with a collision model
 	if ( handle != -1 ) {
 		switch( contact.type ) {
 			case CONTACT_EDGE: {
 				// the model contact feature is a collision model edge
 				collisionModelManager->GetModelEdge( handle, contact.modelFeature, start, end );
 				winding += start;
 				winding += end;
 				break;
 			}
 			case CONTACT_MODELVERTEX: {
 				// the model contact feature is a collision model vertex
 				collisionModelManager->GetModelVertex( handle, contact.modelFeature, start );
 				winding += start;
 				break;
 			}
 			case CONTACT_TRMVERTEX: {
 				// the model contact feature is a collision model polygon
 				collisionModelManager->GetModelPolygon( handle, contact.modelFeature, winding );
 				break;
 			}
 		}
 	}
 
 	// transform the winding to world space
 	if ( clipModel ) {
 		for ( i = 0; i < winding.GetNumPoints(); i++ ) {
 			winding[i].ToVec3() *= clipModel->axis;
 			winding[i].ToVec3() += clipModel->origin;
 		}
 	}
 
 	return true;
 }
 
 /*
 ============
 idClip::PrintStatistics
 ============
 */
 void idClip::PrintStatistics() {
 	gameLocal.Printf( "t = %-3d, r = %-3d, m = %-3d, render = %-3d, contents = %-3d, contacts = %-3d\n",
 					numTranslations, numRotations, numMotions, numRenderModelTraces, numContents, numContacts );
 	numRotations = numTranslations = numMotions = numRenderModelTraces = numContents = numContacts = 0;
 }
 
 /*
 ============
 idClip::DrawClipModels
 ============
 */
 void idClip::DrawClipModels( const idVec3 &eye, const float radius, const idEntity *passEntity ) {
 	int				i, num;
 	idBounds		bounds;
 	idClipModel		*clipModelList[MAX_GENTITIES];
 	idClipModel		*clipModel;
 
 	bounds = idBounds( eye ).Expand( radius );
 
 	num = idClip::ClipModelsTouchingBounds( bounds, -1, clipModelList, MAX_GENTITIES );
 
 	for ( i = 0; i < num; i++ ) {
 		clipModel = clipModelList[i];
 		if ( clipModel->GetEntity() == passEntity ) {
 			continue;
 		}
 		if ( clipModel->renderModelHandle != -1 ) {
 			gameRenderWorld->DebugBounds( colorCyan, clipModel->GetAbsBounds() );
 		} else {
 			collisionModelManager->DrawModel( clipModel->Handle(), clipModel->GetOrigin(), clipModel->GetAxis(), eye, radius );
 		}
 	}
 }
 
 /*
 ============
 idClip::DrawModelContactFeature
 ============
 */
 bool idClip::DrawModelContactFeature( const contactInfo_t &contact, const idClipModel *clipModel, int lifetime ) const {
 	int i;
 	idMat3 axis;
 	idFixedWinding winding;
 
 	if ( !GetModelContactFeature( contact, clipModel, winding ) ) {
 		return false;
 	}
 
 	axis = contact.normal.ToMat3();
 
 	if ( winding.GetNumPoints() == 1 ) {
 		gameRenderWorld->DebugLine( colorCyan, winding[0].ToVec3(), winding[0].ToVec3() + 2.0f * axis[0], lifetime );
 		gameRenderWorld->DebugLine( colorWhite, winding[0].ToVec3() - 1.0f * axis[1], winding[0].ToVec3() + 1.0f * axis[1], lifetime );
 		gameRenderWorld->DebugLine( colorWhite, winding[0].ToVec3() - 1.0f * axis[2], winding[0].ToVec3() + 1.0f * axis[2], lifetime );
 	} else {
 		for ( i = 0; i < winding.GetNumPoints(); i++ ) {
 			gameRenderWorld->DebugLine( colorCyan, winding[i].ToVec3(), winding[(i+1)%winding.GetNumPoints()].ToVec3(), lifetime );
 		}
 	}
 
 	axis[0] = -axis[0];
 	axis[2] = -axis[2];
 	gameRenderWorld->DrawText( contact.material->GetName(), winding.GetCenter() - 4.0f * axis[2], 0.1f, colorWhite, axis, 1, 5000 );
 
 	return true;
 }