///*********************************************************************
//*	Map Loader
//*	SOURCE FILE
//*	Autor:	Michal Jirouš
//*	Datum: 29.7.2008
//*	Soubor: game_loadmap.cpp
//*	Popis: Trida obsahuje funkce pro nacitani levelu ve formatu *.map,
//*			ktery pouzivat Valve hammer editor. Jeji funkce vytvareji 
//*			podle zdrojovych dat objekty a nastavuje jejich vlastnosti.
//**********************************************************************/
//
//#include "game_loadmap.h"
//#include "game.h"
//#include <fstream>
//#include <sstream>
//#include "game_loadingscreen.h"
//#include "game_musicplayer.h"
//#include "mathematic.h"
//#include "func_ladder.h"
//#include "game_environment.h"
//#include "ctrl_var_definition.h"
//
//#include "env_model.h"
//#include "item_target.h"
//#include "item_breakable.h"
//#include "func_breakable.h"
//#include "func_shootswitch.h"
//#include "item_weapons.h"
//#include "item_ammos.h"
//using namespace std;
//CLoadMap maploader;
//
//
//Uint32 updateTime = 0;
//const Uint32 UPDATE_PERIOD = 30;
//
//
//float g_fWorldspawnProgress = 0; 
//float g_fReadPart = 0.5f;
//
//void CLoadMap::updateLoadingScreen()
//{
//	if( updateTime + UPDATE_PERIOD <= SDL_GetTicks() )
//	{
//		size_t uiReadedData = m_uiFileSize - m_pLexan.getRemainingString().length();
//		float progress = (float)uiReadedData / (float)m_uiFileSize;
//		progress *= g_fReadPart;	//podil na postupu
//		loadingScreen::loading_screen.setProgress( progress + g_fWorldspawnProgress  );
//		loadingScreen::loading_screen.loading_func();
//		updateTime = SDL_GetTicks();
//	}	
//}
//
//
///*
//	hardcore class :)
//
//*/
//void CLoadMap::init()
//{
//
//
//	m_pLexan.setSkippingEmptyCharacters( true );
//	m_pLexan.setDefaultEmptyCharactersSettings(true);
//
//	for(int i = 32; i < 128; i++)
//	{
//		//if( isalpha(i) || isdigit(i) )
//			m_pLexan.setAllowedCharacter(i);
//	}
//	//l.setAllowedCharacters("+-*/^!=.()");
//
//	m_pLexan.createDefaultNode();
//	m_pLexan.setDefaultReturnValue( LDMAP_IDENTIFICATOR );
//	//m_pLexan.setDefaultReturnValue( LDMAP_IDENTIFICATOR );	//defaultni return lex. analyzatoru
//	for( int i = 0; i < LEXAN_FIELD_SIZE; i++ )
//	{
//		if(i > 31 && i < 128)
//		m_pLexan.setCycleForChar( i );	//vsechny znaky (tj. klavesy mohou byt ident
//	}
//	
//	
//	m_pLexan.setEndCharacters("\"");
//	m_pLexan.init();
//
//	m_pLexan.addSubject("\"", LDMAP_QUOTES, true );
//	m_pLexan.addSubject("(", LDMAP_LEFT_PARENTHESIS, true );
//	m_pLexan.addSubject(")", LDMAP_RIGHT_PARENTHESIS, true );
//	m_pLexan.addSubject("{", LDMAP_LEFT_VINCULUM, true );
//	m_pLexan.addSubject("}", LDMAP_RIGHT_VINCULUM, true );
//	m_pLexan.addSubject("[", LDMAP_LEFT_BRACKET, true );
//	m_pLexan.addSubject("]", LDMAP_RIGHT_BRACKET, true );
//	
//	/*for( int i = 0; i < LEXAN_FIELD_SIZE; i++ )	//prazdne znaky jsou zakoncovaci
//	{
//		if(isspace(i))
//		{
//			m_pLexan.addSubject( string()+(char)i , LEXAN_SPACE, true);
//			m_pLexan.setEndCharacters(string()+(char)i);
//		}
//	}*/
//	//m_pLexan.setSkippingEmptyCharacters( true );	//vynechavame prazdne znaky
//	
//}
//
//void CLoadMap::loadMap(string filename)
//{
//	//m_pModelLibrary.clear();	//vymazeme vsechny modely
////	m_iDListIndex = 20;
//	
//	/*variable *pVariable = gamevarsLibrary::getVariable("leveldetail");
//	if( pVariable != NULL && pVariable->idata > 0 && pVariable->idata < 7)
//		m_iLevelDetail = pVariable->idata;
//	else*/
//		//m_iLevelDetail = 1;
//
//	resetToNewObject();	//inicializace
//	filename = "Maps/" + filename;
//	ifstream fin( filename.c_str() );
//	
//	if(!fin.is_open())
//	{	
//		fin.close();
//		fin.clear();
//		filename = filename + ".map";
//		fin.open( filename.c_str() );
//		if(!fin.is_open())
//			return;
//	}
//
//	ostringstream out;
//	char c = 0;
//	while( !fin.eof())	//cely soubor ulozime do stringu
//	{
//		c = (char)fin.get();
//		out << c;
//		if(c == -1)
//			break;
//	}
//	fin.close();
//	fin.clear();
//	/*
//		File loaded
//	*/
//	
//	m_pLexan.loadString( out.str() );
//	m_uiFileSize = m_pLexan.getRemainingString().length();
//	float fStartLoadingValue = loadingScreen::loading_screen.getProgress();
//	out.clear();
//	//nyni to analyzujeme
//	
//	/* REKURZIVNI SESTUP */
//	//int iValue = 0;
//	m_iLexSymbol = LDMAP_NO_SYMBOL;
//
//	g_fWorldspawnProgress = 0;
//	while( show() != END_OF_FILE )
//	{
//		updateLoadingScreen();
//
//		resetToNewObject();
//		switch( show() )
//		{
//			case LDMAP_LEFT_VINCULUM:	//prisla leva slozena zavorka, zacina definice objektu
//				compare( show() );
//				//object = new Object();
//				ANA_ObjectDefinition();
//				if(compare( LDMAP_RIGHT_VINCULUM ))
//				{
//					createPolygons();
//					break;
//				}
//				
//			default:	//v pripade chyby cteme az do znaku {
//				readTillChar( '{' );
//		}
//	}
//	loadingScreen::loading_screen.setProgress( 1.0f  );
//	loadingScreen::loading_screen.loading_func();
//}
//
//
//
//
///* metoda REKURZIVNIHO SESTUPU */
//void CLoadMap::ANA_ObjectDefinition()
//{
//	if( show() == END_OF_FILE ) return;
//
//	string sParamName, sParamValue;
//
//	switch( show() )
//	{
//		case LDMAP_LEFT_VINCULUM:	//zacina definice rovin
//			while( show() == LDMAP_LEFT_VINCULUM)	
//			{
//				compare( show() );
//				m_LoadingBrushes.addNode( alg::LoadingBrush() );	//nacitame novy brush
//				ANA_Face();	//definice rovin
//				compare( LDMAP_RIGHT_VINCULUM );
//				//object->brushList.push_back( brush );	//ulozime brush k objektu
//			}
//			break;
//		case LDMAP_QUOTES:	//cteni parametru
//			compare( show() );
//			sParamName = m_pLexan.readTillCharacter( '"' );
//			compare( LDMAP_QUOTES );
//			if(!compare( LDMAP_QUOTES ))
//				return;
//			sParamValue =  m_pLexan.readTillCharacter( '"' );
//			compare( LDMAP_QUOTES );
//			parameterMap.insert( make_pair(sParamName, sParamValue) );
//			if( sParamName == "music" )	//TODO
//			{
//				music_player::openMusic( ("Sounds/Music/" + sParamValue).c_str() );
//				music_player::fadein( -1, 3000 );
//			}
//
//
//			ANA_ObjectDefinition();
//			break;
//		default:
//			return;
//	}
//}
//
///* metoda REKURZIVNIHO SESTUPU, funkce analyzuje roviny a vlastnosti textury roviny */
//void CLoadMap::ANA_Face()
//{
//	if( show() == END_OF_FILE ) return;
//
//	if( show() == LDMAP_LEFT_PARENTHESIS )
//	{
//		compare( show());
//		alg::Point a, b, c;
//		alg::Vector x, y;
//		float fX_move, fY_move, fRotation, fScaleX, fScaleY;
//		string sTextureName;
//		
//		//prvni bod
//		a.x = readFValue();
//		a.y = readFValue();
//		a.z = readFValue();
//
//		if(!compare( LDMAP_RIGHT_PARENTHESIS ) )
//			return;
//
//		if(!compare( LDMAP_LEFT_PARENTHESIS ) )
//			return;
//
//		//druhy bod
//		b.x = readFValue();
//		b.y = readFValue();
//		b.z = readFValue();
//		
//		if(!compare( LDMAP_RIGHT_PARENTHESIS ) )
//			return;
//
//		if(!compare( LDMAP_LEFT_PARENTHESIS ) )
//			return;
//
//		//treti bod
//		c.x = readFValue();
//		c.y = readFValue();
//		c.z = readFValue();
//		
//		if(!compare( LDMAP_RIGHT_PARENTHESIS ) )
//			return;
//		sTextureName.clear();
//		if( show() == LDMAP_LEFT_VINCULUM )
//		{
//			// { muze byt tez soucasti nazvu textury (pouze na zacatku)
//			compare( LDMAP_LEFT_VINCULUM );
//			if(show() != LDMAP_IDENTIFICATOR)
//				return;
//			sTextureName+='{';
//
//		}
//		else if( show() != LDMAP_IDENTIFICATOR)
//			return;
//
//		//jmeno textury
//		sTextureName += m_pLexan.getSymbolName();
//		compare( show() );
//
//
//		if(!compare( LDMAP_LEFT_BRACKET ) )
//			return;
//		
//		//osa X textury
//		x.x = readFValue();
//		x.y = readFValue();
//		x.z = readFValue();
//		
//		//posun v ose X
//		fX_move = readFValue();
//
//		if(!compare( LDMAP_RIGHT_BRACKET ) )
//			return;
//
//		if(!compare( LDMAP_LEFT_BRACKET ) )
//			return;
//		
//		//osa Y textury
//		y.x = readFValue();
//		y.y = readFValue();
//		y.z = readFValue();
//		
//		//posun v ose Y
//		fY_move = readFValue();
//
//		if(!compare( LDMAP_RIGHT_BRACKET ) )
//			return;
//
//		fRotation = readFValue();
//		fScaleX = readFValue();
//		fScaleY = readFValue();
//
//		/*
//			Vytvoreni roviny
//		*/
//		alg::LoadingPlane plane;
//		
//		plane.m_fRotate = fRotation;
//		plane.m_fScaleX = fScaleX;
//		plane.m_fScaleY = fScaleY;
//
//		plane.m_fShiftY = fY_move;
//		plane.m_fShiftX = fX_move;
//
//		plane.m_sTextureName = sTextureName;
//		plane.m_vecTexXaxis = x;
//		plane.m_vecTexYaxis = y;
//		plane.m_points.push(  a );
//		plane.m_points.push(  b );
//		plane.m_points.push(  c );
//
//		
//		m_LoadingBrushes.root->pointer.m_planes.addNode( plane );
//		//brush->planeList.push_back( plane );	//vlozime rovinu do listu rovin v brushy
//		
//		updateLoadingScreen();
//		ANA_Face();	//pokracujeme v analyze
//	}
//}
//
//
//CElevator *elevator = NULL;
//
//
//
///* Z rovin brushe vytvori polygony */
//void CLoadMap::createPolygons( )
//{
//	
//	CBaseObject *baseObject = NULL;	//zde se vytvori novy objekt a analyzuji se parametry
//	if(!parameterMap.empty())
//	{
//		Vector origin;
//		Vector angles;
//
//		map<string,string>::iterator iterClassName = parameterMap.find("origin");
//		if(iterClassName != parameterMap.end())
//			origin = Vector( iterClassName->second );	//stred
//
//		iterClassName = parameterMap.find("angles");
//		if(iterClassName != parameterMap.end())
//			angles = Vector( iterClassName->second );	//otoceni
//
//		
//
//		iterClassName = parameterMap.find("classname");		//jmeno tridy objektu
//		if(iterClassName != parameterMap.end())
//		{
//			if( iterClassName->second == "worldspawn")
//			{
//				Worldspawn *newObject = new Worldspawn();
//				//game.addObject( new CEdge( pObject->firstBrush ) );
//				//float fDistance = 4096.0f;
//				//string skyname = "2desert";		//default value
//
//				iterClassName = parameterMap.find("MaxRange");
//				if(iterClassName != parameterMap.end())
//				{
//					float distance = stringToFloat( iterClassName->second );
//					gamevarsLibrary::setVariable( vardef::MAX_DISTANCE_NAME, distance );
//				}
//									
//				iterClassName = parameterMap.find("skyname");
//				if(iterClassName != parameterMap.end())
//					environment.setSkyName(  iterClassName->second );
//				
//				iterClassName = parameterMap.find("HighMap");
//				if(iterClassName != parameterMap.end())
//					environment.setHighMapPicture(  iterClassName->second );
//
//				iterClassName = parameterMap.find("HighMapGround");
//				if(iterClassName != parameterMap.end())
//					environment.setHighMapParms(  stringToFloat( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("HighMapElemSize");
//				if(iterClassName != parameterMap.end())
//					environment.setElemSize(  stringToFloat( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("HighMapAlphaUnit");
//				if(iterClassName != parameterMap.end())
//					environment.setAlphaUnit(  stringToFloat( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("HighMapSizePerPixel");
//				if(iterClassName != parameterMap.end())
//					environment.setSizePerPixel(  stringToFloat( iterClassName->second ) );
//				
//				iterClassName = parameterMap.find("HighMapTextureRepeat");
//				if(iterClassName != parameterMap.end())
//					environment.setTextureRepeat(  stringToInt( iterClassName->second ) );
//				//newObject->setSky( fDistance, m_iDListIndex, skyname, game.m_pPlayer);
//			
//
//				/*iterClassName = parameterMap.find("music");
//				if(iterClassName != parameterMap.end() && !iterClassName->second.empty())
//					game.loadEnvironmentMusic( iterClassName->second );*/
//
//				//m_iDListIndex += 6;	//sky bere 6 faces
//				baseObject = newObject;
//				
//			}
//			else if( iterClassName->second == "info_player_start")
//			{
//				origin.z += PLAYER_HEIGHT / 2;
//				game.m_pPlayer->teleport( -origin );
//				game.m_pPlayer->m_fRotZaxis = angles[1];
//				game.m_pPlayer->m_fRotXaxis = -angles[0];
//			}
//			else if( iterClassName->second == "func_door")
//			{
//				CDoors *newDoor = new CDoors(  );
//
//				newDoor->setMemberVariables( &parameterMap );
//
////				newDoor->setTextSource( game.getLucidaConsole(), game.getWidth(), game.getHeight() );
//				baseObject = newDoor;
//			}
//			else if( iterClassName->second == "func_illusionary")
//			{
//				Illusionary *newObject = new Illusionary();
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "button_target")
//			{
//				CButton *newObject = new CButton( );
//				
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					newObject->setFlags( stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("returntime");
//				if(iterClassName != parameterMap.end())
//					newObject->setResetTime( stringToInt( iterClassName->second ) );
//				
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "env_message")
//			{
//				/*CMessage *newObject = new CMessage( game.getLucidaConsole(), game.getWidth(), game.getHeight() );
//
//				iterClassName = parameterMap.find("fadetime");
//				if(iterClassName != parameterMap.end())
//					newObject->setFadeTime( stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("message");
//				if(iterClassName != parameterMap.end())
//					newObject->setMessage(  iterClassName->second );
//				
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					newObject->setFlags(  stringToInt( iterClassName->second ) );
//
//				int x_pos = -1, y_pos = -1;
//				iterClassName = parameterMap.find("xposition");
//				if(iterClassName != parameterMap.end())
//					x_pos  = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("yposition");
//				if(iterClassName != parameterMap.end())
//					y_pos  = stringToInt( iterClassName->second );
//				
//				newObject->setPosition( x_pos, y_pos );
//				baseObject = newObject;*/
//			}
//			else if( iterClassName->second == "trigger_once")
//			{
//				CTriggerOnce *newObject = new CTriggerOnce();
//				iterClassName = parameterMap.find("delay");
//				if(iterClassName != parameterMap.end())
//					newObject->setDelay(  stringToInt( iterClassName->second ) );
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "trigger_hurt")
//			{
//				CTriggerHurt *newObject = new CTriggerHurt( game.m_pPlayer );
//
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					newObject->setFlags(  stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("dmg");
//				if(iterClassName != parameterMap.end())
//					newObject->setDamage(  stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("resettime");
//				if(iterClassName != parameterMap.end())
//					newObject->setDelay(  stringToInt( iterClassName->second ) );
//
//				
//				iterClassName = parameterMap.find("delay");
//				if(iterClassName != parameterMap.end())
//					newObject->setDelay(  stringToInt( iterClassName->second ) );
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "trigger_multiple")
//			{
//				CTriggerMultiple *newObject = new CTriggerMultiple( );
//				iterClassName = parameterMap.find("wait");
//				if(iterClassName != parameterMap.end())
//					newObject->setDelay(  stringToInt( iterClassName->second ) );
//
//				
//				iterClassName = parameterMap.find("delay");
//				if(iterClassName != parameterMap.end())
//					newObject->setDelay(  stringToInt( iterClassName->second ) );
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "light_environment")
//			{
//				
//				iterClassName = parameterMap.find("_light");
//				if(iterClassName != parameterMap.end())
//				{
//					float *rgba = NULL;
//					rgba = stringToFloat4( iterClassName->second );
//					if( rgba )
//						game.setSkyColor( Color(rgba[0], rgba[1], rgba[2]) );
//					delete [] rgba;
//					//game.setSkyDensity( rgba[3] );
//	
//				}
//				
//				iterClassName = parameterMap.find("pitch");
//				if(iterClassName != parameterMap.end())
//				{
//					Vector pitch;
//					pitch.createFrom2Angles( stringToFloat (iterClassName->second), angles[1]-90.0f);
//					GLfloat f[3];
//					for( int i = 0; i < 3; i++)
//						f[i] = pitch[i];
//					game.setSkyPosition( f );
//	
//				}
//				game.setSkyEnable( true );
//			}
//			else if( iterClassName->second == "info_teleport_destination")
//			{
//				CInfoTeleDest *newObject = new CInfoTeleDest();
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "trigger_teleport")
//			{
//				CTriggerTeleport *newObject = new CTriggerTeleport( game.m_pPlayer );
//								
//				iterClassName = parameterMap.find("delay");
//				if(iterClassName != parameterMap.end())
//					newObject->setDelay(  stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					newObject->setFlags(  stringToInt( iterClassName->second ) );
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "trigger_gravity")
//			{
//				CTriggerGravity *newObject = new CTriggerGravity();
//								
//				iterClassName = parameterMap.find("gravity");
//				if(iterClassName != parameterMap.end())
//					newObject->setGravity(  stringToFloat( iterClassName->second ) );
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "env_fade")
//			{
//				CEnv_Fade *newObject = new CEnv_Fade( &game.m_pFade );
//								
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					newObject->setFlags(  stringToInt( iterClassName->second ) );
//				
//				iterClassName = parameterMap.find("duration");
//				if(iterClassName != parameterMap.end())
//					newObject->setFadeTime(  stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("renderamt");
//				if(iterClassName != parameterMap.end())
//					newObject->setAlpha(  stringToFloat( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("rendercolor");
//				if(iterClassName != parameterMap.end())
//					newObject->setColor(  Vector( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("holdtime");
//				if(iterClassName != parameterMap.end())
//					newObject->setHoldTime(  stringToInt( iterClassName->second ) );
//
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "item_target")
//			{
//				CTarget *newObject = new CTarget( game.setTaker());
//				game.incrementNumTargets();				
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "env_sprite")
//			{
//				CEnvSprite *newObject = new CEnvSprite( game.m_pPlayer );
//				
//				iterClassName = parameterMap.find("framerate");
//				if(iterClassName != parameterMap.end())
//					newObject->setRate(  stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("model");
//				if(iterClassName != parameterMap.end())
//					newObject->setSpriteName(  iterClassName->second );
//
//				iterClassName = parameterMap.find("scale");
//				if(iterClassName != parameterMap.end())
//					newObject->setScale(  stringToFloat( iterClassName->second ) );
//				
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					newObject->setFlags(  stringToInt( iterClassName->second ) );
//
//				iterClassName = parameterMap.find("startpoint");
//				if(iterClassName != parameterMap.end())
//					newObject->setStartObject( iterClassName->second );
//
//				iterClassName = parameterMap.find("endpoint");
//				if(iterClassName != parameterMap.end())
//					newObject->setEndObject( iterClassName->second );
//
//				iterClassName = parameterMap.find("textureoption");
//				if(iterClassName != parameterMap.end())
//					newObject->setTextureOption( atoi(iterClassName->second.c_str()) );
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "info_target")
//			{
//				CInfoTarget *newObject = new CInfoTarget();
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "env_model")
//			{
//				CEnvModel *newObject = new CEnvModel( );
//				iterClassName = parameterMap.find("model");
//				if(iterClassName != parameterMap.end())
//					newObject->setModel( iterClassName->second);
//
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "item_attack_target")
//			{
//				CAttackTarget *newObject = new CAttackTarget();
////				m_iDListIndex++;	//potrebuje 2
//				game.incrementNumTargets();	
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "infodecal")
//			{
//				CInfoDecal *newObject = new CInfoDecal();
//				game.insertDecal( newObject );
//				iterClassName = parameterMap.find("texture");
//				if(iterClassName != parameterMap.end())
//					newObject->setTexture( iterClassName->second );
//				newObject->setOrigin( origin );
//				
//			}
//			else if( iterClassName->second == "func_invisible")
//			{
//				FuncInvisible *newObject = new FuncInvisible( );
//				baseObject = newObject;
//			
//			}
//			else if( iterClassName->second == "func_wall")
//			{
//				FuncWall *newObject = new FuncWall( );
//				baseObject = newObject;
//			
//			}
//			else if( iterClassName->second == "env_time")
//			{
//				CEnvTimer *newObject = new CEnvTimer( );
//				baseObject = newObject;
//			
//			}
//			else if( iterClassName->second == "env_fog")
//			{
//				int fogtype = 0;
//				iterClassName = parameterMap.find("color");
//				if(iterClassName != parameterMap.end())
//					game.setFogColor( Vector( iterClassName->second) );
//				
//				
//				iterClassName = parameterMap.find("fogtype");
//				if(iterClassName != parameterMap.end())
//					fogtype = stringToInt (iterClassName->second);
//
//				iterClassName = parameterMap.find("start");
//				if(iterClassName != parameterMap.end())
//					game.setFogStart( stringToFloat( iterClassName->second) );
//
//				iterClassName = parameterMap.find("end");
//				if(iterClassName != parameterMap.end())
//					game.setFogEnd( stringToFloat( iterClassName->second) );
//				
//				iterClassName = parameterMap.find("density");
//				if(iterClassName != parameterMap.end())
//					game.setFogDensity( stringToFloat( iterClassName->second) );
//
//				game.setFogType( fogtype );
//				game.setFogEnable( true );
//			}
//			else if( iterClassName->second == "multi_manager")
//			{
//				CMultiManager *newObject = new CMultiManager();
//
//				for(map<string,string>::iterator i = parameterMap.begin(); i != parameterMap.end(); i++)
//				{
//					if( (*i).first != "targetname" && (*i).first != "classname" && (*i).first != "origin" && (*i).first != "angle" && (*i).first != "renderamt" && (*i).first != "rendercolor" && (*i).first != "duration")
//					{
//						newObject->insertOperation( stringToFloat( (*i).second ), (*i).first);
//					}
//				}
//
//				baseObject = newObject;
//			}
//			else if( iterClassName->second == "cloth_simul")
//			{
//				int width = 0, height = 0;
//				float distance = 0.0f;
//				string sConstraint;
//				Vector axis, haxis;
//				iterClassName = parameterMap.find("width");
//				if(iterClassName != parameterMap.end())
//					width = stringToInt( iterClassName->second );
//					
//				iterClassName = parameterMap.find("height");
//				if(iterClassName != parameterMap.end())
//					height = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("distance");
//				if(iterClassName != parameterMap.end())
//					distance = stringToFloat( iterClassName->second );
//
//				iterClassName = parameterMap.find("axis");
//				if(iterClassName != parameterMap.end())
//					axis = Vector( iterClassName->second );
//
//				iterClassName = parameterMap.find("haxis");
//				if(iterClassName != parameterMap.end())
//					haxis = Vector( iterClassName->second );
//
//				iterClassName = parameterMap.find("constraints");
//				if(iterClassName != parameterMap.end())
//					sConstraint = iterClassName->second;
//
//				TextureElement *tmp = NULL;
//				
//				/*iterClassName = parameterMap.find("texture");
//				if(iterClassName != parameterMap.end())
//					tmp=	textureLibrary::applyTexture( iterClassName->second );*/
//				CClothSimul *tmpSimul = new CClothSimul( width, height, distance, tmp, axis,sConstraint,haxis);
//
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					tmpSimul->setParameters( stringToInt( iterClassName->second ) );
//				baseObject = tmpSimul;
//			}
//			else if( iterClassName->second == "env_fan")
//			{
//				int iStartForce = 50, iRandomAngleTime = 5, iRadius = 512, iRandomForceTime = 5,iDelayAngleTime = 5, iDelayForceTime = 1;
//				Vector direction;
//				int flags = 0;
//				iterClassName = parameterMap.find("spawnflags");
//				if(iterClassName != parameterMap.end())
//					flags = stringToInt( iterClassName->second );
//				
//				iterClassName = parameterMap.find("startvalue");
//				if(iterClassName != parameterMap.end())
//					iStartForce = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("angletime");
//				if(iterClassName != parameterMap.end())
//					iDelayAngleTime = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("forcetime");
//				if(iterClassName != parameterMap.end())
//					iDelayForceTime = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("forcerandom");
//				if(iterClassName != parameterMap.end())
//					iRandomForceTime = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("anglerandom");
//				if(iterClassName != parameterMap.end())
//					iRandomAngleTime = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("radius");
//				if(iterClassName != parameterMap.end())
//					iRadius = stringToInt( iterClassName->second );
//
//				iterClassName = parameterMap.find("direction");
//				if(iterClassName != parameterMap.end())
//					direction = Vector( iterClassName->second );
//
//				CFan *newFan = new CFan(direction, iDelayAngleTime, iRadius, iStartForce, flags,iDelayForceTime,iRandomAngleTime,iRandomForceTime);
//				game.insertFan( newFan );
//				baseObject = newFan;
//			}
//			else if( iterClassName->second == "func_elevator")
//			{
//				CElevator *tmpObject = new CElevator();
//				elevator = tmpObject;
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "func_water")
//			{
//				CWater  *tmpObject = new CWater();
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "func_ladder")
//			{
//				CLadder  *tmpObject = new CLadder();
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "func_passworder" )
//			{
//				CPassworder *tmpObject = new CPassworder();
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "env_text" )
//			{
//				CEnvText *tmpObject = new CEnvText();
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "info_command" )
//			{
//				CInfoCommand *tmpObject = new CInfoCommand();
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "item_breakable" )
//			{
//				ItemBreakable *tmpObject = new ItemBreakable();
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "func_breakable" )
//			{
//				FuncBreakable *tmpObject = new FuncBreakable();
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "func_shootswitch" )
//			{
//				FuncShootSwitch *tmpObject = new FuncShootSwitch();
//				tmpObject->setMemberVariables( &parameterMap );
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "item_knife" )
//			{
//				ItemWeaponKnife  *tmpObject = new ItemWeaponKnife();
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "item_9mmpistol" )
//			{
//				ItemWeapon9mmPistol  *tmpObject = new ItemWeapon9mmPistol();
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "item_mp5" )
//			{
//				ItemWeaponMP5  *tmpObject = new ItemWeaponMP5();
//				baseObject = tmpObject;
//			}
//			else if( iterClassName->second == "item_9mmammo" )
//			{
//				ItemAmmo9mm  *tmpObject = new ItemAmmo9mm();
//				baseObject = tmpObject;
//			}
//				
//			
//		}
//		
//		if(baseObject != NULL)	//standardni parametry objektu
//		{
//			//defaultni
//			iterClassName = parameterMap.find("rendercolor");
//			if(iterClassName != parameterMap.end())
//				baseObject->setColor( Vector( iterClassName->second ) );
//
//			iterClassName = parameterMap.find("targetname");
//			if(iterClassName != parameterMap.end())
//				baseObject->setName( iterClassName->second );
//
//			iterClassName = parameterMap.find("target");
//			if(iterClassName != parameterMap.end())
//				baseObject->setTargetName( iterClassName->second );
//			
//			float x = angles[2], y = angles[0], z = angles[1];
//			//z -= 90.0f;	//synchronizace editoru s programem
//			baseObject->setAngle( Vector( x, y, z ) );
//			baseObject->setOrigin( origin );
//			
//			//pokud objekt vyzaduje blending, tak je objekt pridan do seznamu takovychto objektu
//			//if(baseObject->isBlending())	
//			//	game.addBlendingObject( baseObject );
//			if( baseObject->getClassName() != "worldspawn")
//			{
//				game.addObject( baseObject );
//			}
//	
//				
//		}
//	}
//
//	createdObject = baseObject;
//
//	if( m_LoadingBrushes.root != NULL && baseObject != NULL )
//	{
//		if( createdObject->getClassName() == "worldspawn")
//		{
//			delete createdObject;
//			BasicLinkedList<LoadingBrush> backup;
//			backup = m_LoadingBrushes;
//			m_LoadingBrushes.deleteAll();
//			size_t uiNumWorldSpawns = 0;
//			for( BasicLinkedList<LoadingBrush>::BasicLink *tmpBrush = backup.root; tmpBrush != NULL; tmpBrush = tmpBrush->next )
//			{
//				//SEM
//				createdObject = new Worldspawn();
//				m_LoadingBrushes.addNode( tmpBrush->pointer );
//				
//				transformPlanesToPolygons();	//finished
//				intersectNewPoints();	//vypocitame nove body	finished
//				sortPointsClockSide();	//seradime body polygonu ve smeru hodinovych rucicek
//				createPointLinks();
//				compilePolygonsFace();
//				
//				game.addObject( createdObject );
//				m_LoadingBrushes.deleteAll();
//				uiNumWorldSpawns++;
//				g_fWorldspawnProgress = (float)uiNumWorldSpawns / (float)backup.size * ( 1.0f - g_fReadPart );
//				updateLoadingScreen();
//			}
//			g_fWorldspawnProgress = 1.0f - g_fReadPart;
//		}
//		else
//		{
//		//pObject->createPlanes();	//spocita se normalovy vektor vsech rovin a tez Distance
//		transformPlanesToPolygons();	//finished
//		intersectNewPoints();	//vypocitame nove body	finished
//		sortPointsClockSide();	//seradime body polygonu ve smeru hodinovych rucicek
//		createPointLinks();
//		compilePolygonsFace();
//		//createPolygonBrush();	//nakonec vytvorime brushe
//		//deleteBrushes();		//pote je muzeme smazat
//		}
//	}
//
//
//	resetToNewObject();
//}
//
//void CLoadMap::transformPlanesToPolygons()
//{
//	BasicLinkedList<alg::LoadingBrush>::BasicLink *tmpBrush = m_LoadingBrushes.root;
//	while( tmpBrush != NULL )
//	{
//		alg::PasiveModelBrush *newPolygonBrush = createdObject->m_PolygonBrushes.addNode( alg::PasiveModelBrush() );
//		//pro vsechny brushe
//		BasicLinkedList<alg::LoadingPlane>::BasicLink *tmpPlane = tmpBrush->pointer.m_planes.root;
//		while( tmpPlane != NULL )
//		{
//			//pro vsechny roviny
//			alg::PasiveModelPlane *newPolygon = newPolygonBrush->m_polygons.addNode( alg::PasiveModelPlane() );
//			alg::LinkedPoint addedPoints[3];
//			int i = 0;
//			while( !tmpPlane->pointer.m_points.empty() && i < 3)
//			{
//				addedPoints[i] << tmpPlane->pointer.m_points.front();
//				alg::LinkedPoint *found = alg::isPointAlreadyInBrush( *newPolygonBrush, addedPoints[i] );
//				if( found == NULL )
//				{
//					found = newPolygonBrush->m_points.addNode( addedPoints[i] );
//				}
//				
//				newPolygon->m_points.addNode( found );
//				
//				tmpPlane->pointer.m_points.pop();
//				i++;
//			}
//			
//			newPolygon->m_vecNormal = alg::Vector( addedPoints[0], addedPoints[1] ) * alg::Vector( addedPoints[2], addedPoints[1] );
//			newPolygon->m_vecNormal.normalize();
//			newPolygon->determineDistance( addedPoints[0] );
//			TextureElement *pTexture = textureLibrary.applyTexture( tmpPlane->pointer.m_sTextureName );
//			if(pTexture != NULL)
//			{
//				newPolygon->m_pTexture = pTexture;
//			}
//			newPolygon->m_pLoadingPlane = &tmpPlane->pointer;	//priradime nahravaci rovinu pro informace o texturovani
//			//newPolygonBrush.m_polygons.addNode( newPolygon );
//			tmpPlane = tmpPlane->next;
//		}
//		
//
//		tmpBrush = tmpBrush->next;	
//	}
//}
//
//
///* Funkce pocita prunik mezi 3 rovinami */
//void CLoadMap::intersectNewPoints()
//{
//	BasicLinkedList<alg::PasiveModelBrush>::BasicLink	*tmpBrush =	createdObject->m_PolygonBrushes.root;
//	while( tmpBrush != NULL )
//	{
//		BasicLinkedList<alg::PasiveModelPlane>::BasicLink *tmpPolygonA = tmpBrush->pointer.m_polygons.root;
//		while( tmpPolygonA != NULL )
//		{
//			BasicLinkedList<alg::PasiveModelPlane>::BasicLink *tmpPolygonB = tmpPolygonA;
//			while( tmpPolygonB != NULL )
//			{
//				BasicLinkedList<alg::PasiveModelPlane>::BasicLink *tmpPolygonC = tmpPolygonB;
//				while( tmpPolygonC != NULL )
//				{
//					/* Zde se provede prunik techto 3 rovin */
//
//					if( tmpPolygonA != tmpPolygonB && tmpPolygonB != tmpPolygonC && tmpPolygonA != tmpPolygonC )
//					{
//						alg::LinkedPoint newLinkedPoint, *addedLinkedPoint;
//						if(alg::planePlanesIntersect( tmpPolygonA->pointer, tmpPolygonB->pointer, tmpPolygonC->pointer, newLinkedPoint ) )
//						{
//							//newLinkedPoint.x = round(newLinkedPoint.x);
//							//newLinkedPoint.y = round(newLinkedPoint.y);
//							//newLinkedPoint.z = round(newLinkedPoint.z);
//							
//							//bod musi lezet v objektu
//							if( !alg::isPointInBrushLoadingVersion(tmpBrush->pointer, newLinkedPoint ) )
//							{
//								tmpPolygonC = tmpPolygonC->next;
//								continue;
//							}
//							
//							addedLinkedPoint = alg::isPointAlreadyInBrush( tmpBrush->pointer, newLinkedPoint );
//							if( addedLinkedPoint == NULL )
//							{
//								addedLinkedPoint = tmpBrush->pointer.m_points.addNode( newLinkedPoint );
//							}
//
//							//pokud bod dosud neni v rovine a do roviny patri, tak je pridan
//							if(alg::isPointOnPlane( tmpPolygonA->pointer, *addedLinkedPoint ) && !alg::isPointAlreadyInPlane( tmpPolygonA->pointer, *addedLinkedPoint ) )
//								tmpPolygonA->pointer.m_points.addNode( addedLinkedPoint );
//
//							if(alg::isPointOnPlane( tmpPolygonB->pointer, *addedLinkedPoint ) && !alg::isPointAlreadyInPlane( tmpPolygonB->pointer, *addedLinkedPoint ) )
//								tmpPolygonB->pointer.m_points.addNode( addedLinkedPoint );
//
//							if(alg::isPointOnPlane( tmpPolygonC->pointer, *addedLinkedPoint ) && !alg::isPointAlreadyInPlane( tmpPolygonC->pointer, *addedLinkedPoint ) )
//								tmpPolygonC->pointer.m_points.addNode( addedLinkedPoint );
//						}
//					}
//
//					/* end */
//					tmpPolygonC = tmpPolygonC->next;
//				}
//
//				tmpPolygonB = tmpPolygonB->next;
//			}
//		
//			tmpPolygonA = tmpPolygonA->next;
//		}
//
//
//
//		tmpBrush = tmpBrush->next;
//	}
//}
//
//
//
//
//
//
//
///* Funkce radi body ve smeru hodinovych rucicek */
//void CLoadMap::sortPointsClockSide()
//{
//	BasicLinkedList<alg::PasiveModelBrush>::BasicLink	*tmpBrush =	createdObject->m_PolygonBrushes.root;
//	while( tmpBrush != NULL )
//	{
//		BasicLinkedList<alg::PasiveModelPlane>::BasicLink *tmpPolygonA = tmpBrush->pointer.m_polygons.root;
//		while( tmpPolygonA != NULL )
//		{
//			const unsigned int iFieldSize = tmpPolygonA->pointer.m_points.size;
//			if( iFieldSize < 3 ) continue; 
//			alg::LinkedPoint **polygonUnsortedPoints = new alg::LinkedPoint*[ iFieldSize ]();
//			unsigned int iIndex = 0;
//			//naplnime pole
//			for( BasicLinkedList<alg::LinkedPoint*>::BasicLink *tmpPoint = tmpPolygonA->pointer.m_points.root; tmpPoint != NULL; tmpPoint = tmpPoint->next )
//			{
//				if( iIndex >= iFieldSize )
//					break;
//
//				polygonUnsortedPoints[ iIndex++ ] = tmpPoint->pointer;
//			}
//		
//			tmpPolygonA->pointer.m_points.deleteAll();	//smazeme seznam bodu a zacneme hledat jine body
//			alg::Vector baseVector( *polygonUnsortedPoints[ iFieldSize-2 ], *polygonUnsortedPoints[ iFieldSize-3 ]  );
//			float fMinAngle = 180.0f;
//			iIndex = -1;
//			for( unsigned int i = 0; i < iFieldSize-3;  ) //prochazime vsechny neserazene body a testujeme uhel
//			{
//				if( polygonUnsortedPoints[ i ] != NULL )
//				{
//					alg::Vector newTestedPointVector( *polygonUnsortedPoints[ i ], *polygonUnsortedPoints[ iFieldSize-3 ] );
//					float angle = abs( baseVector.scalarMultiply( newTestedPointVector ) );
//					if( angle < fMinAngle )
//					{
//						fMinAngle = angle;
//						iIndex = i;
//					}
//				}
//
//				if( i == iFieldSize - 4 && iIndex != -1)	//test posledniho prvku a bod byl nalezen
//				{
//					fMinAngle = 180.0f;
//					tmpPolygonA->pointer.m_points.addNode( polygonUnsortedPoints[ iIndex ] );
//					polygonUnsortedPoints[ iIndex ] = NULL;
//					iIndex = -1;
//					i = 0;	//a jedeme znovu :)
//				}
//				else
//					i++;
//			}
//		
//			for( unsigned int i = iFieldSize-3; i <iFieldSize; i++ )
//			{
//				tmpPolygonA->pointer.m_points.addNode( polygonUnsortedPoints[ i ] );
//			}
//
//			delete [] polygonUnsortedPoints;
//
//			tmpPolygonA = tmpPolygonA->next;
//		}
//
//		tmpBrush = tmpBrush->next;
//	}
//
//	/*vector<Point*> tmpPointList;
//	vector<Point*> tmpWorkList;
//	//pro kazdy brush
//	for(list<Brush*>::iterator i = pObject->brushList.begin(); i != pObject->brushList.end(); i++)
//	{
//		//pro vsechny roviny
//		for(list<Plane*>::iterator j = (*i)->planeList.begin(); j != (*i)->planeList.end(); j++)
//		{
//			if((*j)->pointList.size() < 3)
//				continue;
//			//prvni 3 jsou vzdy spravne (vyplyva z generovani editoru)
//			tmpPointList.push_back( (*j)->pointList[0] );
//			tmpPointList.push_back( (*j)->pointList[1] );
//			tmpPointList.push_back( (*j)->pointList[2] );
//		
//			for(unsigned int k=3;k<(*j)->pointList.size(); k++)	//od 4. bodu vkladame do pomocneho listu
//			{
//				tmpWorkList.push_back( (*j)->pointList[k] );	//vlozime neserazene body
//			}
//
//			(*j)->pointList.clear();
//			//nyni muzeme zacit s razenim
//
//			if(tmpPointList.size() < 3)
//				continue;
//
//			float angle = 0.0f;
//			while( !tmpWorkList.empty() )	//budeme prchazet, dokud bude co radit
//			{
//				size_t iFirst = tmpPointList.size() - 1;
//				size_t iSecond = tmpPointList.size() - 2;
//				vector<Point*>::iterator pointIterator = tmpWorkList.begin();
//				//zakladni vektor, se kterym budeme porovnavat uhel
//				Vector base( tmpPointList[ iSecond ]->x - tmpPointList[ iFirst ]->x, tmpPointList[ iSecond ]->y - tmpPointList[ iFirst ]->y, tmpPointList[ iSecond ]->z - tmpPointList[ iFirst ]->z);
//				for( vector<Point*>::iterator L = tmpWorkList.begin(); L !=  tmpWorkList.end();L++)
//				{
//					//iFirst je spolecni bod, ve kterem se pocita uhel
//					float tmpAngle = base.scalarMultiply( Vector( (*L)->x - tmpPointList[ iFirst ]->x, (*L)->y - tmpPointList[ iFirst ]->y, (*L)->z - tmpPointList[ iFirst ]->z) );
//					if( tmpAngle > angle )
//					{
//						angle = tmpAngle;	//nasli jsme novy uhel
//						pointIterator = L;
//					}
//					
//				}
//				//nalezeny bod vlozime do seznamu
//				tmpPointList.push_back( (*pointIterator) );
//				tmpWorkList.erase( pointIterator );	//a vyjmeme ho z pracovniho seznamu
//				angle = 0.0f;
//			}
//
//			//serazeny list ulozime zpet
//			for(unsigned int k = 0; k < tmpPointList.size(); k++)
//			{
//				(*j)->pointList.push_back( tmpPointList[k] );
//			}
//
//			tmpPointList.clear();
//		}
//	}*/
//}
//
//void CLoadMap::createPointLinks()
//{
//	BasicLinkedList<alg::PasiveModelBrush>::BasicLink	*tmpBrush =	createdObject->m_PolygonBrushes.root;
//	while( tmpBrush != NULL )
//	{
//		tmpBrush->pointer.recalculateBoundingBox();	//vytvorime boundingbox nad brushem
//		BasicLinkedList<alg::PasiveModelPlane>::BasicLink *tmpPolygonA = tmpBrush->pointer.m_polygons.root;
//		while( tmpPolygonA != NULL )
//		{
//			tmpPolygonA->pointer.m_Bounds.setBasicValues( *tmpPolygonA->pointer.m_points.root->pointer );
//			for( BasicLinkedList<alg::LinkedPoint*>::BasicLink *tmpPoint = tmpPolygonA->pointer.m_points.root; tmpPoint != NULL; tmpPoint = tmpPoint->next )
//			{
//				tmpPolygonA->pointer.m_Bounds.updateData( *tmpPoint->pointer );
//				alg::LinkedPoint *A = tmpPoint->pointer, *B;	//pro vytvoreni vazby
//				if( tmpPoint->next == NULL )
//					B = tmpPolygonA->pointer.m_points.root->pointer;
//				else
//					B = tmpPoint->next->pointer;
//	
//				alg::Abscissa * newAbscissa = alg::isAbscissaAlreadyInBrush( tmpBrush->pointer, *A, *B );
//				if( newAbscissa == NULL )	//zatim neni
//				{
//					A->m_Neightbours.addNode( B );
//					B->m_Neightbours.addNode( A );
//					newAbscissa = tmpBrush->pointer.m_abscissas.addNode( alg::Abscissa( A, B ) );
//				}
//				
//				tmpPolygonA->pointer.m_abscissas.addNode( newAbscissa );
//			}
//
//			tmpPolygonA = tmpPolygonA->next;
//		}
//
//		tmpBrush = tmpBrush->next;
//	}
//}
//
//void CLoadMap::compilePolygonsFace()
//{
//	BasicLinkedList<alg::PasiveModelBrush>::BasicLink	*tmpBrush =	createdObject->m_PolygonBrushes.root;
//	while( tmpBrush != NULL )
//	{
//		BasicLinkedList<alg::PasiveModelPlane>::BasicLink *tmpPolygonA = tmpBrush->pointer.m_polygons.root;
//		while( tmpPolygonA != NULL )
//		{
//			tmpPolygonA->pointer.m_iDlistID = glGenLists(1);
//			int iTextureWidth = 0, iTextureHeight = 0;
//			glNewList( tmpPolygonA->pointer.m_iDlistID, GL_COMPILE);		//vytvorime novy list
//				if( tmpPolygonA->pointer.m_pTexture )
//				{
//					
//					iTextureWidth = tmpPolygonA->pointer.m_pTexture->image.width;
//					iTextureHeight = tmpPolygonA->pointer.m_pTexture->image.height;
//				}
//			//TextureElement *pTexture = textureLibrary.getTexture( tmpPolygonA->pointer.m_iTextureID );
//			
//			//if(pTexture != NULL)
//			//{
//				//newPolygon->texture = pTexture->texture_id;
//
//			//	iTextureWidth = pTexture->image.width;
//			//	iTextureHeight = pTexture->image.height;
//			//}	
//
//			
//			
//				
//			
//			glBegin(GL_TRIANGLE_FAN);
//				glNormal3f(tmpPolygonA->pointer.m_vecNormal[0], tmpPolygonA->pointer.m_vecNormal[1], tmpPolygonA->pointer.m_vecNormal[2]);
//
//				for( BasicLinkedList<alg::LinkedPoint*>::BasicLink *tmpPoint = tmpPolygonA->pointer.m_points.root; tmpPoint != NULL; tmpPoint = tmpPoint->next )
//				{
//					//vypocet texturovacich souradnic
//					tmpPoint->pointer->m_fXcoord = ( tmpPoint->pointer->Dot( tmpPolygonA->pointer.m_pLoadingPlane->m_vecTexXaxis ) / tmpPolygonA->pointer.m_pLoadingPlane->m_fScaleX + tmpPolygonA->pointer.m_pLoadingPlane->m_fShiftX ) / iTextureWidth;
//					tmpPoint->pointer->m_fYcoord = ( tmpPoint->pointer->Dot( -tmpPolygonA->pointer.m_pLoadingPlane->m_vecTexYaxis ) / tmpPolygonA->pointer.m_pLoadingPlane->m_fScaleY - tmpPolygonA->pointer.m_pLoadingPlane->m_fShiftY ) / iTextureHeight;
//					glTexCoord2f( tmpPoint->pointer->m_fXcoord, tmpPoint->pointer->m_fYcoord );
//					glVertex3f(tmpPoint->pointer->x, tmpPoint->pointer->y, tmpPoint->pointer->z);
//				}
//			glEnd();
//			glEndList();
//
//			tmpPolygonA = tmpPolygonA->next;
//		}
//
//		tmpBrush = tmpBrush->next;
//	}
//
//
//}
//
//
//
///* Funkce vytvari polygony, zavadi triangulaci a nastavuje jmena brushum a polygonum */
//void CLoadMap::createPolygonBrush()
//{
//	/*m_uiBrushIndex = 0;
//	//musime projet vsechny brushe
//	for(list<Brush*>::iterator i = pObject->brushList.begin(); i != pObject->brushList.end(); i++)
//	{
//		if((*i)->planeList.empty())
//			continue;
//
//		polygonBrush *newPolygonBrush = new polygonBrush();
//		newPolygonBrush->m_uiSelectionName = m_uiBrushIndex++;	//jmeno brushe
//		if(newPolygonBrush == NULL)
//			continue;
//
//		m_iuPolygonIndex = 0;
//		//a tez vsechny roviny abychom vytvorily polygon
//		for(list<Plane*>::iterator j = (*i)->planeList.begin(); j != (*i)->planeList.end(); j++)
//		{
//			polygon *newPolygon = new polygon();
//			if(newPolygon == NULL)
//				continue;
//			newPolygon->m_uiSelectionName = m_iuPolygonIndex++;	//jmeno polygonu
//			newPolygon->d = (*j)->fDistance;
//			newPolygon->normal = (*j)->vecNormal;
//			newPolygon->id = m_iDListIndex++;	//index do display listu
//			newPolygon->triangulatedDListID = m_iDListIndex++;
//			if((*j)->pointList.size() < 3)
//			{
//				delete newPolygon;
//				continue;
//			}
//
//
//			//musime body pridat od zadu, aby zustaly serazeny ve smeri hod. rucicek (ehm iterator--????)
//			while(!(*j)->pointList.empty())
//			{
//				newPolygon->addPoint( new point( (*j)->pointList.back()->x, (*j)->pointList.back()->y, (*j)->pointList.back()->z ));
//				//newPolygon->num_Points++;
//				(*j)->pointList.pop_back();
//			}
//					
//			int iTextureWidth = 0, iTextureHeight = 0;
//
//			glNewList( newPolygon->id, GL_COMPILE);		//vytvorime novy list
//
//			TextureElement *pTexture = game.pTexs.getTex((*j)->sTextureName);
//			if(pTexture != NULL)
//			{
//				newPolygon->texture = pTexture->texture_id;
//				glMaterialfv(GL_FRONT, GL_SPECULAR, pTexture->materialSpecular);
//				glMaterialfv(GL_FRONT, GL_DIFFUSE, pTexture->materialDiffuse);
//				glMaterialfv(GL_FRONT, GL_AMBIENT, pTexture->materialAmbient);
//				glMaterialfv(GL_FRONT, GL_SHININESS, pTexture->materialShininess);
//				iTextureWidth = pTexture->width;
//				iTextureHeight = pTexture->height;
//			}	
//
//			
//			
//				
//			//kazdy objekt ma 2 D-listy (jeden polygonovy - jednoduchy pro selection mod) a druhy triangulovany
//			glBegin(GL_POLYGON);
//				glNormal3f(newPolygon->normal.field[0], newPolygon->normal.field[1], newPolygon->normal.field[2]);
//
//				point *tmpPoint = newPolygon->firstPoint;
//				while(tmpPoint != NULL)
//				{
//					//vypocet texturovacich souradnic
//					float fCoordX = ( tmpPoint->Dot( (*j)->texXAxis ) / (*j)->fScaleX + (*j)->fX_move ) / iTextureWidth;
//					float fCoordY = ( tmpPoint->Dot( (*j)->texYAxis ) / (*j)->fScaleY + (*j)->fY_move ) / iTextureHeight;
//					glTexCoord2f(fCoordX, fCoordY);
//					glVertex3f(tmpPoint->x, tmpPoint->y, tmpPoint->z);
//					tmpPoint = tmpPoint->next;
//				}
//			glEnd();
//			glEndList();
//			
//			
//
//			CTriangulation pTria;
//			glNewList( newPolygon->triangulatedDListID, GL_COMPILE);		//vytvorime novy list
//			glNormal3f(newPolygon->normal[0], newPolygon->normal[1], newPolygon->normal[2]);
//				if(pTexture != NULL)
//				{
//					glMaterialfv(GL_FRONT, GL_SPECULAR, pTexture->materialSpecular);
//					glMaterialfv(GL_FRONT, GL_DIFFUSE, pTexture->materialDiffuse);
//					glMaterialfv(GL_FRONT, GL_AMBIENT, pTexture->materialAmbient);
//					glMaterialfv(GL_FRONT, GL_SHININESS, pTexture->materialShininess);
//				}	
//				//triangulace s vykreslenim pomoci triagle stripu
//				pTria.triangulate(newPolygon, 15, (*j)->texXAxis, (*j)->texYAxis, (*j)->fX_move, (*j)->fY_move, iTextureWidth, iTextureHeight,(*j)->fScaleX,(*j)->fScaleY, m_iLevelDetail);
//			glEndList();
//			
//			newPolygon->next = newPolygonBrush->firstPolygon;
//			newPolygonBrush->firstPolygon = newPolygon;
//		}
//
//		newPolygonBrush->next = pObject->firstBrush;
//		pObject->firstBrush = newPolygonBrush;
//	}*/
//
//}
//
///* Smaze pomocne brushe spolu se vsemy rovinami a body */
//void CLoadMap::deleteBrushes()
//{
//	/*for(list<Brush*>::iterator i = pObject->brushList.begin(); i != pObject->brushList.end(); i++)
//	{
//		for(list<Plane*>::iterator j = (*i)->planeList.begin(); j != (*i)->planeList.end(); j++)
//		{
//			for(vector<Point*>::iterator k = (*j)->pointList.begin(); k != (*j)->pointList.end(); k++)
//			{
//				delete (*k);
//				(*k) = NULL;
//			}
//			delete (*j);
//			(*j) = NULL;
//		}
//		delete (*i);
//		(*i) = NULL;
//	}
//	brush = NULL;*/
//
//}
//
///* Inicializace pro dalsi analyzu */
//void CLoadMap::resetToNewObject(void)
//{
//	m_LoadingBrushes.deleteAll();
//	parameterMap.clear();
//	createdObject = NULL;
//	
//	/*if(brush != NULL)
//	{
//		delete brush;
//		brush = NULL;
//	}
//
//	if(object != NULL)
//	{
//		delete object;
//		object = NULL;
//	}*/
//
//
//    
//}
//
///* Nacte pomoci lexikalniho analyzatoru cele cislo */
//int CLoadMap::readIValue()
//{
//	if( show() == LDMAP_IDENTIFICATOR )
//	{
//		compare( show() );
//		return stringToInt(	m_pLexan.getSymbolName() );
//	}
//	return 0;
//
//}
//
///* Nacte pomoci lexikalniho analyzatoru cislo s pohyblivou radovou carkou */
//float CLoadMap::readFValue()
//{
//	if( show() == LDMAP_IDENTIFICATOR )
//	{
//		compare( show() );
//		return stringToFloat(	m_pLexan.getSymbolName() );
//	}
//	return 0.0f;
//}
//
///* Nacte pomoci lexikalniho analyzatoru vektor */
//Vector CLoadMap::readVector()
//{
//	if( show() == LDMAP_IDENTIFICATOR )
//	{
//		compare( show() );
//		return Vector(	m_pLexan.getSymbolName() );
//	}
//	return Vector();
//}
//