///**************************************
//*	collision.cpp
//*	Autor: Michal Jirous
//*	Popis: Funkce pro vypocet detekce kolizi
//*			
//*
//***************************************/
//
//#include "collision.h"
//#include "mathematic.h"
//#include "func_ladder.h"
//#include "ctrl_var_definition.h"
//#include "object_info.h"
//CCollision collision;
//
//bool CCollision::collisionDetection(bObject *O, CPlayer *pPlayer)
//{
//	//m_bLockForceMovingObjects = false;
//	//m_pPlayer = pPlayer;
//	//bool lastAirValue = m_pPlayer->isInAir;				//ulozime si posledni znamy Air level	
//	//int iLastWaterLevel = m_pPlayer->m_iWaterLevel;		//ulozime si posledni znamy Water level	
//	//m_pPlayer->m_bJumpoutOfWater = false;				//Reset skoku z vody
//	//m_pPlayer->m_iWaterLevel = NOT_IN_WATER;			//reset Water levelu...
//	//m_pPlayer->isInAir = true;							//reset Air levelu
//	//bool bIsColliding = false;							//pomocna promenna urcujici, zda nastala kolize
//	//bool stairs = false;								//chuze do schodu se pocita pouze 1x; tato promenna to zajistuje
//	//
//	////Parametry detekce kolizi
//	//alg::Vector vecNormal;						//vysledna normala detekce kolizi
//	//m_lightForceVector = Vector();				//vektor, ktery je nasledne pripocitavan k pohybu hrace v pripade kolize s pohyblivym objektem
//	//float fStairsMax = 0.0f, fDistance = 0.0f;	//promenne vlastniho vypoctu kolizi: nejvyssi hodnota na ose Z a vzdalenost od nejblizsiho kolizniho bodu
//
//	//bool bCollisionDetected = false;
//
//	////pohyb pri navratu ze skrceni
//	//if( !m_pPlayer->m_iIsDucking && m_pPlayer->m_iDuckOffset > 0 )
//	//{
//	//	float backspd = PLAYER_HEIGHT / 2;
//	//	float spd = (float)m_pPlayer->m_iDuckOffset;
//	//	m_pPlayer->m_ActiveBrush.createMovedBrush( Vector( 0,0, - spd - 1 ) ); //TODO_VEC
//	//	fDistance = spd;
//	//	
//	//	bIsColliding = octreeCollisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax );
//
//	//	if( !bIsColliding )
//	//	{
//	//		for( int i = 0; i < 4; i++)
//	//			m_pPlayer->m_ActiveBrush.top[i]->z += spd;		//muzeme se posunout vzhuru
//	//		m_pPlayer->m_ActiveBrush.m_middleCenterPoint.z += spd / 2;
//	//		m_pPlayer->m_ActiveBrush.m_Bounds.m_fBounds[ MAX_Z ] += spd;
//	//		m_pPlayer->m_ActiveBrush.m_topCenterPoint.z = m_pPlayer->m_ActiveBrush.m_Bounds.m_fBounds[ MAX_Z ];
//	//		m_pPlayer->m_iDuckOffset = 0;
//	//		m_pPlayer->m_fTransZ -= spd;
//	//	}
//	//}
//
//	//bool bTargetCanAcceptVector = false;	//udava, zda se v prvni fazi detekce kolizi naslo reseni
//	//bool bLadderTested = false;
//	//for( int i = 0; i < 5; i++ )
//	//{
//	//	bIsColliding = false;
//	//	bool ladderMovement = false;
//	//	//nastaveni parametru a vytvoreni protazeneho modelu
//	//	
//	//	//test zachyceni se zebriku pri pohybu shora dolu
//	//	//testuje se pouze jednou
//	//	if( lastAirValue && m_pPlayer->m_bPosibleLadderDownMovement )
//	//	{
//	//		Vector reverse = -m_pPlayer->m_vecMove * 2.0f; 
//	//		fDistance = reverse.absolute();
//	//		reverse.z = 0;
//	//		
//	//		m_pPlayer->m_ActiveBrush.createMovedBrush( reverse ); 
//	//		m_pPlayer->m_bPosibleLadderDownMovement = false;
//	//		if( m_pPlayer->m_pLadder->collisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax ) )
//	//		{
//	//			Vector horizontal = Vector( vecNormal.x, vecNormal.y, 0 );
//	//			if( horizontal != Vector() && horizontal.scalarMultiply( vecNormal ) < COLL_LADDER_NORMAL_MAX_ANGLE )
//	//			{
//	//				setLadderParameters( fDistance, vecNormal, m_pPlayer->m_pLadder );
//	//				break;
//	//			}
//	//		}
//	//	}
//
//	//	//Test pritomnosti na zebriku
//	//	//ted musime otestovat jestli jsme stale na zebriku
//	//	if( !bLadderTested && m_pPlayer->m_bIsOnLadder )	//nejprve test, zda minule kolo byl hrac na zebriku
//	//	{
//	//		bLadderTested = true;
//	//		CBaseObject *m_pLadder = m_pPlayer->m_pLadder;
//	//		fDistance = m_pPlayer->m_fLastLadderDistance + ALG_COLLISION_DETECT_2ND_PHASE_BOUNDS_RANGE;
//	//		Vector thisMove = Vector( m_pPlayer->m_vecLastLadderNormal, fDistance );
//	//		m_pPlayer->m_ActiveBrush.createMovedBrush( thisMove ); //TODO_VEC
//	//		
//	//		if( m_pLadder->collisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax ) )
//	//		{
//	//			//jsem stale na zebriku a vykonam pohyb po nem
//	//			Vector finnishedVector = transformLadderMovement( -m_pPlayer->m_vecMove, vecNormal ); //TODO_VEC
//	//		
//	//			Vector v = finnishedVector * vecNormal;
//	//			Vector resultsMove = vecNormal * v;
//	//			//TODO_VEC
//	//			m_pPlayer->setMoveVector( -resultsMove );	//ano, je tam potreba opacny smer
//	//			continue;	//po vykonu pohybu po zebriku musi pokracovat detekce kolizi dalsim krokem
//	//		}
//	//		else
//	//			m_pPlayer->m_bIsOnLadder = false;	//konec pohybu po zebriku a pokracujeme normalni detekci
//	//	}
//	//	
//	//	
//	//	/************************************************************
//	//	*	DEFAULT COLLISION DETECTION
//	//	*	= Zakladni detekce koliznich bodu, vypocet kolizni roviny,
//	//	*	nejvyssiho kolizniho ( kvuli chuzi do schodu )
//	//	*	= Vypocet pohybu po schodech a skoku z vody
//	//	*************************************************************/
//	//	
//	//	fStairsMax = m_pPlayer->m_ActiveBrush.m_Bounds.m_fBounds[ MIN_Z ];
//	//	fDistance = (m_pPlayer->m_vecMove - m_lightForceVector).absolute();
//	//	m_pPlayer->m_ActiveBrush.createMovedBrush( m_pPlayer->m_vecMove - m_lightForceVector); //TODO_VEC
//
//	//	//detekce koliznich bodu, vysledneho normaloveho vektoru
//	//	bIsColliding = octreeCollisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax );
//	//	
//	//	if( !bIsColliding )
//	//	{
//	//		bTargetCanAcceptVector = true;
//	//		break;
//	//	}
//	//	else
//	//	{
//	//		bCollisionDetected = true;
//
//	//		//Test, zda hrac nenarazil do zebriku
//	//		//a zde se mrkneme na ten zebrik
//	//		if( m_pCollisionSubject && m_pCollisionSubject->getClassName() == "func_ladder" )
//	//		{
//	//			//Musime otestovat uhel normaloveho vektoru kolizni roviny zebriku
//	//			//vzhledem k horizontalni rovine
//	//			Vector vecHorizontal = Vector( vecNormal.x, vecNormal.y, 0 );
//	//			if( vecHorizontal != Vector() && vecHorizontal.scalarMultiply( vecNormal ) < COLL_LADDER_NORMAL_MAX_ANGLE )
//	//			{
//	//				setLadderParameters( fDistance, vecNormal, m_pCollisionSubject );
//	//				m_pPlayer->m_bPosibleLadderDownMovement = false;
//	//				break;
//	//			}
//	//			else if( m_pPlayer->m_bIsOnLadder == false )
//	//			{	
//	//				//Pripad uhlu vetsiho nez limit natoceni zebriku. V tom pripade je mozne,
//	//				//ze nastane pohyb po zebriku dolu
//	//				m_pPlayer->m_bPosibleLadderDownMovement = true;
//	//				m_pPlayer->m_pLadder = m_pCollisionSubject;
//	//			}
//	//			
//	//		}
//	//		else
//	//			m_pPlayer->m_bPosibleLadderDownMovement = false;
//
//
//	//		Vector finalVector = resultsVectors( m_pPlayer->m_vecMove, vecNormal);
//	//		//Vector finalLightForce = resultsVectors( m_lightForceVector, vecNormal );
//
//	//		if( m_pCollisionSubject && m_pCollisionSubject->isForceColliding() )
//	//		{
//	//			if( vecNormal.scalarMultiply( Vector( 0,0,1) ) < 30.0f )
//	//				m_lightForceVector = m_pCollisionSubject->getForcedVector();
//	//		}
//	//		else
//	//			m_lightForceVector = Vector();
//
//	//		//vysledny vektor pohybu
//	//		
//	//		
//	//		/*	Chuze do schodu
//	//		*	testujeme, zda maximalni hodnota kolizniho bodu je maximalne o 24 bodu vyssi nez minimalni hodnota na ose Z
//	//		*	hracova modelu
//	//		*	pokud to projde, tak otestujeme, zda je mozne pohyb do schodu provest
//	//		*/	
//
//	//		if( !stairs )
//	//		{
//	//			float minStairs = m_pPlayer->m_ActiveBrush.m_Bounds.m_fBounds[ MIN_Z ];
//	//			if( fStairsMax + 0.000001 > minStairs && fStairsMax < minStairs + COLL_STAIRS_ADDITIONAL_HEIGHT &&
//	//				!compareFloats(vecNormal[2],0.0f, 0.1f) )
//	//			{
//	//				stairs = true;
//	//				float value = fStairsMax - minStairs;	//Rozdil vysek = cilova vzdalenost
//	//				alg::Vector stairsVector( -m_pPlayer->m_vecMove[0], -m_pPlayer->m_vecMove[1], value + 1.0f );
//
//	//				m_pPlayer->teleport( Vector(0,0, -stairsVector[2]) ); //TODO_VEC
//	//				Vector bck = m_pPlayer->m_vecMove;
//	//				m_pPlayer->setMoveVector( Vector(-stairsVector[0], -stairsVector[1], 0) ); //TODO_VEC
//	//				
//	//				m_pPlayer->m_ActiveBrush.createMovedBrush( m_pPlayer->m_vecMove ); //TODO_VEC
//
//	//				float fDistanceBck = fDistance;
//	//				fDistance = m_pPlayer->m_vecMove.absolute() + 1.0f;
//	//				
//	//				m_bLockForceMovingObjects = true;
//	//				bIsColliding =  octreeCollisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax );
//	//				m_bLockForceMovingObjects = false;
//	//				fDistance = fDistanceBck;
//	//				if( bIsColliding  )
//	//				{
//	//					m_pPlayer->setMoveVector( bck );
//	//					m_pPlayer->teleport( Vector(0,0,stairsVector[2]) ); //TODO_VEC
//	//				}
//	//				
//	//				if(!bIsColliding)
//	//				{
//	//					m_pPlayer->acceptVector( m_pPlayer->m_vecMove ); //TODO_VEC
//	//					return false;	//TODO..prece nemuzu vypadnout? co force moving?
//	//				}
//	//			
//	//				stairs = false;
//	//			}
//	//			else if( iLastWaterLevel > LEGS_IN_WATER && fStairsMax + 0.000001 > minStairs			&&
//	//				fStairsMax < minStairs + PLAYER_HEIGHT + COLL_JUMP_OUT_OF_WATER_ADDITIONAL_HEIGHT	&&
//	//				!compareFloats( vecNormal[2], 0.0f, 0.1f) )
//	//			{
//	//				m_pPlayer->m_bJumpoutOfWater = true;
//	//			}
//	//		}
//	//		
//	//		/*****************************************************************************************************/
//	//		
//	//		//nastavime vysledny vektor pohybu a inicializujeme hodnoty na dalsi detekci
//
//	//		
//	//		if( fDistance > 1.0f )
//	//		{
//	//			m_pPlayer->acceptVector( Vector(m_pPlayer->m_vecMove - m_lightForceVector, fDistance - 1.0f ) );
//	//		}
//
//	//		m_pPlayer->setMoveVector( finalVector ); //TODO_VEC
//	//	}
//	//}
//	//
//
//	//if( bTargetCanAcceptVector )
//	//	m_pPlayer->acceptVector( m_pPlayer->m_vecMove - m_lightForceVector ); //TODO_VEC
//
//	//Vector hhh = m_pPlayer->m_vecMove;
//	//bool f = bTargetCanAcceptVector;
//	////nyni nastava faze, kdy je treba spocitat kolize s pohyblivymi objekty
//	//Vector forceVector;
//	//m_bLockForceMovingObjects = true;
//	//for( std::list<CBaseForceMovingObject*>::iterator tmpForceMovingObject = m_ForceMovingObjects.begin();
//	//	tmpForceMovingObject != m_ForceMovingObjects.end(); tmpForceMovingObject++ )
//	//{
//	//	//jako vektor pohybu pouzijeme vektor pohybu hrace secteny s opacnym vektorem pohybu objektu
//	//	Vector thisMove = /*m_pPlayer->m_vecMove +*/ (*tmpForceMovingObject)->getForcedVector(); //TODO_VEC
//	//	
//	//	m_pPlayer->m_ActiveBrush.createMovedBrush( thisMove ); //TODO_VEC
//	//	
//	//	fDistance = thisMove.absolute();
//	//	if( (*tmpForceMovingObject)->collisionDetection( m_pPlayer, vecNormal, fDistance , fStairsMax ) )
//	//	{
//	//		bTargetCanAcceptVector = false;
//
//	//		forceVector = resultsVectorsMove( thisMove, vecNormal, (*tmpForceMovingObject)->getForcedVector() ) - (*tmpForceMovingObject)->getForcedVector();	
//	//		m_pPlayer->m_vecMove = forceVector; //TODO_VEC
//	//		
//	//		m_pPlayer->m_ActiveBrush.createMovedBrush( m_pPlayer->m_vecMove ); //TODO_VEC
//	//		fDistance = m_pPlayer->m_vecMove.absolute();
//	//		
//	//		bIsColliding = octreeCollisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax );
//	//		if(! bIsColliding || (*tmpForceMovingObject) == m_pCollisionSubject )
//	//			m_pPlayer->acceptVector( forceVector ); //TODO_VEC
//	//		else
//	//			(*tmpForceMovingObject)->forceMoveCollision( m_pPlayer );
//	//		//bIsColliding = octreeCollisionDetection( m_pPlayer, vecNormal, fDistance, fStairsMax );
//	//	}
//	//	else
//	//		m_bLockForceMovingObjects = m_bLockForceMovingObjects;
//	//}
//
//	//
//	//
//	//return bCollisionDetected;
//return true;
//}
//
//void CCollision::setLadderParameters( float fDistance, Vector &vecLadderNormal, CBaseObject *pLadder )
//{
//	m_pPlayer->m_fLastLadderDistance = fDistance;
//	m_pPlayer->m_bIsOnLadder = true;
//	m_pPlayer->m_vecLastLadderNormal = vecLadderNormal;
//	m_pPlayer->m_pLadder = pLadder;
//	m_pPlayer->setMoveVector( Vector() );
//}
//
//Vector CCollision::resultsVectors( Vector &move, Vector &normal )
//{
//	Vector v = move * normal;
//	Vector f = normal * v;
////
////	float x = normal.scalarMultiply(alg::Vector(0.0f, 0.0f, 1.0f));
////	
////	/* pokud je uhel mezi osou x a vyslednym normalovym vektorem mensi 
////	nez 40, tak hrac stoji na zemi a neni ve vzduchu */
////	if( x < COLL_GROUND_DETECT_ANGLE )
////	{
////		Vector abc = move * Vector(0.0f, 0.0f, 1.0f);
////		Vector ggg = Vector(0.0f, 0.0f, 1.0f) * abc;
////
////		Vector xyz = normal * abc;
////		m_pPlayer->isInAir = false;
////		m_pPlayer->m_bIsOnLadder = false;	//konec ladder pohybu
////		f = Vector( f, xyz.absolute() );
////		f = xyz;
/////*
////		float hhh = ggg.scalarMultiply( normal );
////		if( hhh > 90.0f )
////		{
////			f = ggg;
////		}*/
////		//pokud padal rychle, pad mu zpusobi zraneni
////		if(move.absolute() > PLAYER_FALL_DAMAGE_SPEED_LIMIT )
////		{
////			float fFallDamage = gamevarsLibrary::getfData( vardef::FALLDAMAGE_NAME );
////			int iDamage = (int)((move.absolute() - PLAYER_FALL_DAMAGE_SPEED_LIMIT) * fFallDamage);
////			m_pPlayer->takeDamage( iDamage );
////			
////			//cout << move.absolute() << " = " << iDamage << " " << endl;
////		}
////	}
//	return f;
//}
//
//Vector CCollision::resultsVectorsMove( Vector &move, Vector &normal, Vector &forceVector )
//{
//	Vector v = move * normal;
//	Vector f = normal * v;
////
////	float x = normal.scalarMultiply(alg::Vector(0.0f, 0.0f, 1.0f));
////	
////	/* pokud je uhel mezi osou x a vyslednym normalovym vektorem mensi 
////	nez 40, tak hrac stoji na zemi a neni ve vzduchu */
////	if( x < COLL_GROUND_DETECT_ANGLE )
////	{
////		float angle = f.scalarMultiply( forceVector );
////		float size = forceVector.absolute() / mycos( angle );
////		f = Vector( f, size );
////	}
////
////
////
//return f;
//	/*Vector v = move * normal;
//	Vector f = normal * v;
//
//	float x = normal.scalarMultiply( forceVector );
//	if(x < 30)
//	{
//		return Vector();
//	}
//	else
//	{
//		float angle = f.scalarMultiply( -forceVector );
//		float size = forceVector.absolute() / mycos( angle );
//		return f = Vector( f, size );
//	}*/
//		
//}
//
//
//using namespace ObjectInfo;
//
//bool CCollision::octreeCollisionDetection( CBaseObject *initiator, Vector &normal, float &fDistance , float &fStairsMax )
//{
//	if( !m_bLockForceMovingObjects )
//		m_ForceMovingObjects.clear();
//	m_pCollisionSubject = NULL;
//	m_iUsabilityCollisionIndex = ObjectInfo::object_info.incrementSearchingIndex();
//
//	m_bResultValue = false;
//
//	m_vecNormal = normal;
//	m_fDistance = fDistance;
//	m_fStairsMax = fStairsMax;
//	m_initiator = initiator;
//
//	if( recursiveDetect( ObjectInfo::object_info.getOctreeRoot() ) )
//	{
//		normal = m_vecNormal;
//		fDistance = m_fDistance;
//		fStairsMax = m_fStairsMax;
//		initiator = m_initiator;
//	}
//	return m_bResultValue;
//}
//
//using namespace ObjectInfo;
//
//bool CCollision::recursiveDetect( ObjectInfo::OctreeNode *node )
//{
//	/*if( !node )
//		return false;
//
//	if( node->m_SceneObjects.size() > 0 && node->m_iParameters & OCTREE_PARAM_COLLIDE )
//	{
//		for( std::list<Leaf*>::iterator iter = node->m_SceneObjects.begin(); iter != node->m_SceneObjects.end(); ++iter )
//		{
//			if( (*iter)->m_uiUsageIndex == m_iUsabilityCollisionIndex || (*iter)->type != MAP_OBJECT )
//				continue;
//				(*iter)->m_uiUsageIndex = m_iUsabilityCollisionIndex;
//			if( !m_bLockForceMovingObjects && (*iter)->data.singleObject->isForceColliding() )
//			{
//				if( m_initiator->m_ActiveBrush.m_MovedBrush.m_Bounds.compare( (*iter)->data.singleObject->m_BoundsOfMove ) )
//					m_ForceMovingObjects.push_back( reinterpret_cast<CBaseForceMovingObject*>( (*iter)->data.singleObject ) );
//			}
//			bool b = (*iter)->data.singleObject->collisionDetection( m_initiator, m_vecNormal, m_fDistance, m_fStairsMax );
//			m_bResultValue |= b;
//				
//			if( b )
//			{
//
//				m_pCollisionSubject = (*iter)->data.singleObject;
//				
//			}
//		}
//	}
//	else
//		for( int i = 0; i < 8; i ++ )
//		{
//			if( node->childs[i] == NULL )
//				continue;
//			
//			if( m_initiator->m_ActiveBrush.m_MovedBrush.m_Bounds.compare( node->childs[i]->m_Bounds ) )
//				m_bResultValue |= recursiveDetect( node->childs[i] );
//		}
//	return m_bResultValue;*/
//	return true;
//}
//
//
//
//
//void CCollision::checkInteraction(alg::Vector &vecDir, CPlayer *pPlayer)
//{
//	/*if( pPlayer == NULL )
//		return;
//
//	float fMaxDistance = gamevarsLibrary::getfData("cl_usedistance");
//	Line interactionLine( -pPlayer->getOrigin(), vecDir);
//	BoundingBox interActionBoundingBox( interactionLine );
//	interActionBoundingBox.updateData( interactionLine + Vector( vecDir, fMaxDistance ) );
//	SceneObject *tmpObject = sceneObjectLibrary::getSceneObjectRoot();
//	Point result;
//	Plane cut( -interactionLine.m_vecDirection );
//	cut.determineDistance( interactionLine );
//	SceneObject target;
//	target.object = NULL;
//	while( tmpObject != NULL )
//	{
//		if( tmpObject->object->isUsable() )
//			tmpObject->object->checkInteraction(interActionBoundingBox, interactionLine, &target, fMaxDistance, result, cut );
//		tmpObject = tmpObject->next;
//	}
//
//	if( target.object != NULL )
//		target.object->onUse();*/
//}
////
////void CCollision::constructDataStructures()
////{
////	m_ForceMovingObjects.deleteAll();
////	SceneObject *tmpObject = sceneObjectLibrary::getSceneObjectRoot();
////	while( tmpObject != NULL )
////	{
////		if( tmpObject->object->isForceColliding() )
////		{
////			m_ForceMovingObjects.addNode( reinterpret_cast<CBaseForceMovingObject*>(tmpObject->object) );
////		}
////
////		tmpObject = tmpObject->next;
////	}
////
////
////	createOctree();
////}
////
////void CCollision::createOctree()
////{
////	/* First, spocitejme celkovy bounding box */ 
////	
////	deleteTree();
////
////	m_CollOctreeRoot = new CollOctreeNode();
////	m_CollOctreeRoot->parent = NULL;
////	SceneObject *tmpObject = sceneObjectLibrary::getSceneObjectRoot();
////	bool boundsSet = false;
////	while( tmpObject != NULL )
////	{
////		if( tmpObject->object->isColliding() && !tmpObject->object->isRandomMoveAble())
////		{
////			if( !boundsSet )
////			{
////				m_CollOctreeRoot->m_Bounds.setBounds( tmpObject->object->m_Bounds );
////				boundsSet = true;
////			}
////
////
////			if( tmpObject->object->isMoveAble() )
////				m_CollOctreeRoot->m_Bounds.updateData( tmpObject->object->m_BoundsOfMove );
////			else
////				m_CollOctreeRoot->m_Bounds.updateData( tmpObject->object->m_Bounds );
////			Leaf *newLeaf = new Leaf();
////			newLeaf->singleObject = tmpObject->object;
////			newLeaf->m_uiUsageIndex = 0;
////			m_CollOctreeRoot->sceneObjects.insert( newLeaf );
////			m_LeafSet.insert( newLeaf );
////		}
////		tmpObject = tmpObject->next;
////	}
////	
////	Point centerPoint = m_CollOctreeRoot->m_Bounds.getCenterPoint();
////	float iMax = 0;
////	for( int i = 0; i < 3; i ++)
////		iMax = max(iMax, abs(m_CollOctreeRoot->m_Bounds.m_fBounds[2*i+1] - m_CollOctreeRoot->m_Bounds.m_fBounds[2*i]) );
////
////	m_CollOctreeRoot->m_Bounds.setBasicValues( centerPoint );
////	m_CollOctreeRoot->m_Bounds.setRange( iMax / 2.0f);
////	m_fMinRange = (float)gamevarsLibrary::getiData( "octree_min_range" );
////	if( m_fMinRange < 16 || m_fMinRange > 2048)
////		m_fMinRange = 32;
////	constructCollisionOctreeNode( m_CollOctreeRoot );
////}
////
////void CCollision::deleteTree()
////{
////	if( m_CollOctreeRoot != NULL )
////		delete m_CollOctreeRoot;
////	
////	m_CollOctreeRoot = NULL;
////	if( !m_LeafSet.empty() )
////	{
////		for( set<Leaf*>::iterator iter = m_LeafSet.begin(); iter != m_LeafSet.end(); ++iter )
////			delete (*iter);
////		m_LeafSet.clear();
////	}
////}
////
////
////void CCollision::constructCollisionOctreeNode( CollOctreeNode *child )
////{
////	float fNewRange = abs( child->m_Bounds.m_fBounds[1] - child->m_Bounds.m_fBounds[0] ) / 2.0f;
////	if( fNewRange  < m_fMinRange )
////		return;
////	float vectorSize = fNewRange / 2;
////	
////	bool isLeaf = true;
////	for( int i = 0; i < 8; i++ )
////	{
////		Vector direction( vectorSize, vectorSize, vectorSize);
////		child->nodes[i] = new CollOctreeNode();	
////		child->nodes[i]->parent = child;
////		child->nodes[i]->m_Bounds.setBasicValues( child->m_Bounds.getCenterPoint() );
////		child->nodes[i]->m_Bounds.setRange( fNewRange / 2.0f);
////
////		if( i & X_DIRECT ) direction.x *= -1;
////		if( i & Y_DIRECT ) direction.y *= -1;
////		if( i & Z_DIRECT ) direction.z *= -1;
////	
////		child->nodes[i]->m_Bounds.translate( direction );
////
////		for( set<Leaf*>::iterator iter = child->sceneObjects.begin(); iter != child->sceneObjects.end(); ++iter )
////		{
////			if( (*iter)->singleObject->m_Bounds.compare( child->nodes[i]->m_Bounds ) )
////			{
////				child->nodes[i]->sceneObjects.insert( *iter );
////			}
////		}
////		
////		if( child->nodes[i]->sceneObjects.size() == 0 )
////		{
////			delete child->nodes[i];
////			child->nodes[i] = NULL;
////		}
////		else
////		{
////			isLeaf = false;
////			constructCollisionOctreeNode( child->nodes[i] );
////		}
////	}
////	if( !isLeaf )
////		child->sceneObjects.clear();
////}