First blood

src/Animation/SalmonAnimation.cpp

@@ -0,0 +1,670 @@
+#include "include/Animation/SalmonAnimation.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+TAnimSequence::TAnimSequence(const TAnimSequence& animSeq)
+{
+
+	BoneCount = animSeq.BoneCount;
+	FrameCount = animSeq.FrameCount;
+
+	BoneInfoMatrix = animSeq.BoneInfoMatrix;
+}
+
+TAnimSequence::~TAnimSequence() 
+{ 
+	Clear();
+}
+
+TAnimSequence& TAnimSequence::operator=(const TAnimSequence& animSeq)
+{
+	if (this == &animSeq)
+		return *this;
+
+	Clear();
+
+	BoneCount = animSeq.BoneCount;
+	FrameCount = animSeq.FrameCount;
+	BoneInfoMatrix = animSeq.BoneInfoMatrix;
+
+	
+
+	return *this;
+
+}
+
+void TAnimSequence::Clear()
+{
+	
+	BoneInfoMatrix.clear();
+	FrameCount = 0;
+	BoneCount = 0;
+	
+
+}
+
+
+bool TAnimSequence::LoadFromFileAn1(const std::string& fileName)
+{
+	Clear();
+
+	int i,j;
+
+	cardinal fSize;
+
+	boost::shared_array<cardinal> fileData = CreateMemFromFile<cardinal>(fileName, fSize);
+
+
+	if ((((char*)&fileData[0])[0] != 'A')||
+		(((char*)&fileData[0])[1] != 'N')||
+		(((char*)&fileData[0])[2] != 0)||
+		(((char*)&fileData[0])[3] != 1))
+		throw ErrorFileNotCorrect(fileName);
+
+
+	if (fSize < 3)
+		throw ErrorFileNotCorrect(fileName);
+
+	BoneCount = fileData[1];
+	FrameCount = fileData[2];
+
+
+	BoneInfoMatrix.resize(FrameCount);
+
+	for (i = 0; i < FrameCount; i++)
+		BoneInfoMatrix[i].resize(BoneCount);
+
+	//Shift from file pointer
+	cardinal filePointer = 3;
+
+	for (i=0; i<FrameCount; i++)
+		for (j=0; j<BoneCount; j++)
+		{
+			if (filePointer+8>fSize)
+			{
+				throw ErrorFileTooShort(fileName);
+			}
+
+			BoneInfoMatrix[i][j].Pos.v[0] = ((float*)&fileData[0])[filePointer++];
+			BoneInfoMatrix[i][j].Pos.v[1] = ((float*)&fileData[0])[filePointer++];
+			BoneInfoMatrix[i][j].Pos.v[2] = ((float*)&fileData[0])[filePointer++];
+			
+			BoneInfoMatrix[i][j].Quat.v[0] = ((float*)&fileData[0])[filePointer++];
+			BoneInfoMatrix[i][j].Quat.v[1] = ((float*)&fileData[0])[filePointer++];
+			BoneInfoMatrix[i][j].Quat.v[2] = ((float*)&fileData[0])[filePointer++];
+			BoneInfoMatrix[i][j].Quat.v[3] = ((float*)&fileData[0])[filePointer++];
+
+			BoneInfoMatrix[i][j].Len = ((float*)&fileData[0])[filePointer++];
+
+			BoneInfoMatrix[i][j].Ancient = 0; //dummy
+			}
+
+	
+	return true;
+}
+
+void TAnimSequence::ScaleAnimSequence(float s)
+{
+
+
+	for (int i=0; i<FrameCount; i++)
+		for (int j=0; j<BoneCount; j++)
+		{
+			BoneInfoMatrix[i][j].Pos *= s;
+			BoneInfoMatrix[i][j].Len *= s;
+		}
+}
+
+
+void TAnimSequence::MoveAnimSequence(const vec3& v)
+{
+	for (int i=0; i<FrameCount; i++)
+		for (int j=0; j<BoneCount; j++)
+		{
+			BoneInfoMatrix[i][j].Pos += v;
+		}
+}
+
+void TAnimSequence::RotateAnimSequence(const mat3& m)
+{
+	vec4 q(m);
+
+	for (int i=0; i<FrameCount; i++)
+		for (int j=0; j<BoneCount; j++)
+		{
+			BoneInfoMatrix[i][j].Pos = m * BoneInfoMatrix[i][j].Pos;
+			BoneInfoMatrix[i][j].Quat = BoneInfoMatrix[i][j].Quat * q;
+		}
+}
+
+
+//======================================================
+//================= Anim List ==========================
+//======================================================
+
+
+
+bool TAnimList::LoadBoneSystemFromFileBn1(const std::string& fileName)
+{
+	Clear();
+
+	int i;
+
+	cardinal fSize;
+	boost::shared_array<cardinal> fileData = CreateMemFromFile<cardinal>(ResourceManager->PathToResources+fileName,fSize);
+
+
+
+	if (fileData == NULL)
+		throw ErrorFileNotLoaded(fileName);
+
+	if ((((char*)&fileData[0])[0]!='B')||
+		(((char*)&fileData[0])[1]!='N')||
+		(((char*)&fileData[0])[2]!=0)||
+		(((char*)&fileData[0])[3]!=1))
+		throw ErrorFileNotCorrect(fileName);
+
+	if (fSize < 3)
+		throw ErrorFileNotCorrect(fileName);
+
+	int boneCount = fileData[1];
+	int vertexCount = fileData[2];
+	
+
+	//Shift from file pointer
+	cardinal filePointer = 3;
+
+	//temporary data storage
+	TBoneStruct boneStruct;
+	TVertexWeightStruct vertexWeightStruct;
+
+
+	for (i=0; i<boneCount; i++)
+	{
+		if (filePointer+9 > fSize)
+			throw ErrorFileTooShort(fileName);
+
+		boneStruct.Pos.v[0] = ((float*)fileData[0])[filePointer++];
+		boneStruct.Pos.v[1] = ((float*)&fileData[0])[filePointer++];
+		boneStruct.Pos.v[2] = ((float*)&fileData[0])[filePointer++];
+			
+		boneStruct.Quat.v[0] = ((float*)&fileData[0])[filePointer++];
+		boneStruct.Quat.v[1] = ((float*)&fileData[0])[filePointer++];
+		boneStruct.Quat.v[2] = ((float*)&fileData[0])[filePointer++];
+		boneStruct.Quat.v[3] = ((float*)&fileData[0])[filePointer++];
+
+		boneStruct.Len = ((float*)&fileData[0])[filePointer++];
+
+		boneStruct.Ancient = fileData[filePointer++];
+
+		BoneList.push_back(boneStruct);
+	}
+
+	for (i=0; i<vertexCount; i++)
+	{
+		if (filePointer + 7 > fSize)
+			throw ErrorFileTooShort(fileName);
+
+		vertexWeightStruct.WeightCount = fileData[filePointer++];
+
+		vertexWeightStruct.VertexBoneInfo.resize(3);
+
+		vertexWeightStruct.VertexBoneInfo[0].BoneNum = fileData[filePointer++];
+		vertexWeightStruct.VertexBoneInfo[0].BoneWeight = ((float*)&fileData[0])[filePointer++];
+		vertexWeightStruct.VertexBoneInfo[1].BoneNum = fileData[filePointer++];
+		vertexWeightStruct.VertexBoneInfo[1].BoneWeight = ((float*)&fileData[0])[filePointer++];
+		vertexWeightStruct.VertexBoneInfo[2].BoneNum = fileData[filePointer++];
+		vertexWeightStruct.VertexBoneInfo[2].BoneWeight = ((float*)&fileData[0])[filePointer++];
+
+		VertexWeightList.push_back(vertexWeightStruct);
+	}
+	
+	
+	Ready = true;
+
+
+	return true;
+}
+
+
+bool TAnimList::LoadBoneSystemFromFileBn2(const std::string& fileName)
+{
+	Clear();
+
+	int i;
+
+	cardinal fSize;
+	boost::shared_array<cardinal> fileData = CreateMemFromFile<cardinal>(ResourceManager->PathToResources+fileName,fSize);
+
+	if (fileData == NULL)
+		throw ErrorFileNotLoaded(fileName);
+
+	if (((reinterpret_cast<char*>(&fileData[0]))[0]!='B')||
+		((reinterpret_cast<char*>(&fileData[0]))[1]!='N')||
+		((reinterpret_cast<char*>(&fileData[0]))[2]!=0)||
+		((reinterpret_cast<char*>(&fileData[0]))[3]!=2))
+		throw ErrorFileNotCorrect(fileName);
+
+	if (fSize < 3)
+		throw ErrorFileNotCorrect(fileName);
+
+	int boneCount = fileData[1];
+	int vertexCount = fileData[2];
+	
+
+	//Shift from file pointer
+	cardinal filePointer = 3;
+
+	//temporary data storage
+	TBoneStruct boneStruct;
+	TVertexWeightStruct vertexWeightStruct;
+
+
+	for (i=0; i<boneCount; i++)
+	{
+		if (filePointer+9 > fSize)
+			throw ErrorFileTooShort(fileName);
+
+		boneStruct.Pos.v[0] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+		boneStruct.Pos.v[1] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+		boneStruct.Pos.v[2] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+			
+		boneStruct.Quat.v[0] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+		boneStruct.Quat.v[1] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+		boneStruct.Quat.v[2] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+		boneStruct.Quat.v[3] = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+
+		boneStruct.Len = (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+
+		boneStruct.Ancient = (reinterpret_cast<int*>(&fileData[0]))[filePointer++];
+
+		BoneList.push_back(boneStruct);
+	}
+
+	for (i=0; i<vertexCount; i++)
+	{
+		if (filePointer + 7 > fSize)
+			throw ErrorFileTooShort(fileName);
+
+		vertexWeightStruct.WeightCount = fileData[filePointer++];
+
+		vertexWeightStruct.VertexBoneInfo.resize(vertexWeightStruct.WeightCount);
+
+		TBoneWeightStruct boneWeightStructZero;
+		boneWeightStructZero.BoneNum = -1;
+		boneWeightStructZero.BoneWeight = -1;
+
+		for (cardinal j=0; j<vertexWeightStruct.VertexBoneInfo.size(); j++)
+		{
+			vertexWeightStruct.VertexBoneInfo[j] = boneWeightStructZero;
+		}
+		
+		
+		for (int j=0; j<vertexWeightStruct.WeightCount; j++)
+		{ 
+			TBoneWeightStruct boneWeightStruct;
+			boneWeightStruct.BoneNum = fileData[filePointer++];
+			boneWeightStruct.BoneWeight =  (reinterpret_cast<float*>(&fileData[0]))[filePointer++];
+			vertexWeightStruct.VertexBoneInfo[j] = boneWeightStruct;
+		}
+		
+		VertexWeightList.push_back(vertexWeightStruct);
+	}
+	
+	
+	Ready = true;
+
+	//delete [] fileData;
+
+	return true;
+}
+
+bool TAnimList::LoadAnimSequenceFromFileAn1(const std::string& fileName)
+{
+	std::string shortFileName(GetFileName((char*)fileName.c_str()));
+
+	if (AnimSequenceMap.count(shortFileName) == 0)
+	{
+		TAnimSequence animSeqience;
+		if (animSeqience.LoadFromFileAn1(ResourceManager->PathToResources+fileName))
+		{
+			AnimSequenceMap[shortFileName] = animSeqience;
+			return true;
+		}
+		else
+			return false;
+	}
+
+	return false;
+}
+
+void TAnimList::Clear()
+{
+	BoneList.clear();
+	VertexWeightList.clear();
+	AnimSequenceMap.clear();
+	Ready = false;
+}
+
+void TAnimList::ScaleAnimList(float s)
+{
+	for (TBoneList::iterator i = BoneList.begin(); i != BoneList.end(); ++i)
+	{
+		i->Pos *= s;
+		i->Len *= s;
+	}
+
+	for (TAnimSequenceMap::iterator j = AnimSequenceMap.begin(); j != AnimSequenceMap.end(); ++j)
+	{
+		j->second.ScaleAnimSequence(s);
+	}
+}
+
+void TAnimList::MoveAnimList(const vec3& v)
+{
+	for (TBoneList::iterator i = BoneList.begin(); i != BoneList.end(); ++i)
+	{
+		i->Pos += v;
+	}
+
+	for (TAnimSequenceMap::iterator j = AnimSequenceMap.begin(); j != AnimSequenceMap.end(); ++j)
+	{
+		j->second.MoveAnimSequence(v);
+	}
+}
+
+void TAnimList::RotateAnimList(const mat3& m)
+{
+	vec4 q(m);
+
+	for (TBoneList::iterator i = BoneList.begin(); i != BoneList.end(); ++i)
+	{
+		i->Pos = m * i->Pos;
+		i->Quat = i->Quat * q;
+	}
+
+	for (TAnimSequenceMap::iterator j = AnimSequenceMap.begin(); j != AnimSequenceMap.end(); ++j)
+	{
+		j->second.RotateAnimSequence(m);
+	}
+}
+
+
+void TAnimList::DrawBoneSystem()
+{
+#ifdef TARGET_WIN32
+	vec3 startpos, endpos;
+	vec4 vx, q, inv_q;
+
+	TBoneList::iterator i;
+
+	for (TBoneList::iterator i = BoneList.begin(); i != BoneList.end(); ++i)
+	{
+		
+		startpos = i->Pos;
+		q = i->Quat;
+
+		vx = vec4(i->Len, 0.0f, 0.0f, 0.0f);
+	
+		inv_q.v[0] = - q.v[0];
+		inv_q.v[1] = - q.v[1];
+		inv_q.v[2] = - q.v[2];
+		inv_q.v[3] = q.v[3];
+
+		vx = q * vx * inv_q;
+		
+		endpos = startpos + vec3(vx);
+
+		glBegin(GL_LINES);
+			glNormal3f(0.0f, 1.0f, 0.0f);
+			glVertex3fv(startpos.v);
+			glVertex3fv(endpos.v);
+		glEnd();
+	}
+#endif
+}
+
+void TAnimList::SaveBoneSystemToBuf()
+{
+	PrevBoneList.assign(BoneList.begin(),BoneList.end());
+}
+
+void TAnimList::LoadBoneSystemFromBuf()
+{
+	BoneList.assign(PrevBoneList.begin(),PrevBoneList.end());
+}
+
+//=====================================================
+//=========== TModelAnimManager =======================
+//=====================================================
+
+TAnimList* TModelAnimManager::operator [] (const std::string& s)
+{
+	if (AnimListMap.count(s) > 0)
+	{
+		return &AnimListMap[s];
+	}
+
+	return NULL;
+}
+
+//NOT SAFE!!! Need to check if model exists in Lite Model Manager and need to check if bone list belongs to this model
+bool TModelAnimManager::AddAnimationToModel(const std::string& modelName, const std::string& boneListFileName)
+{
+	if (AnimListMap.count(modelName) == 0)
+	{
+		//TODO: Make switch
+		//if (!AnimListMap[modelName].LoadBoneSystemFromFileBn1(boneListFileName))
+		if (!AnimListMap[modelName].LoadBoneSystemFromFileBn2(boneListFileName))
+		{
+			AnimListMap.erase(modelName);
+			return false;
+		}
+
+		return true;
+	}
+	return false;
+}
+
+void TModelAnimManager::Clear()
+{
+	
+	AnimListMap.clear();
+}
+	
+
+//==================================================
+//=============== ANIM MODEL =======================
+//==================================================
+
+
+
+
+void TAnimModel::RecalcVertexPos()
+{
+	
+	int i,j,nBone;
+	mat3 R, R0, dR;
+	vec4 dq,inv_q;
+	vec4 q0;
+	vec4 q;
+	vec4 inv_q0;
+	vec4 inv_dq;
+	//vec3 endbone0;
+	vec3 endbone;
+	vec3 p[20];//TODO: MAKE THIS DYNAMIC!!!!
+	vec3 PrevPos,dbp,px;
+
+	//float n;
+
+	int VertexCount = LiteModel.TriangleCount * 3;
+
+	
+	
+	for (i=0; i<VertexCount; i++)
+	{
+		PrevPos = CopyVertexArr[i];
+
+		int weightCount = AnimList->VertexWeightList[i].WeightCount;
+
+		for (j=0; j<weightCount; j++)
+		{
+			
+			nBone = AnimList->VertexWeightList[i].VertexBoneInfo[j].BoneNum;
+
+			q0 = AnimList->PrevBoneList[nBone].Quat;
+			
+			inv_q0 = q0;
+
+			inv_q0.v[0] = - inv_q0.v[0];
+			inv_q0.v[1] = - inv_q0.v[1];
+			inv_q0.v[2] = - inv_q0.v[2];
+			inv_q0.v[3] = inv_q0.v[3];
+
+			q = AnimList->BoneList[nBone].Quat;
+
+			inv_q = q;
+
+			inv_q.v[0] = - inv_q.v[0];
+			inv_q.v[1] = - inv_q.v[1];
+			inv_q.v[2] = - inv_q.v[2];
+			inv_q.v[3] = inv_q.v[3];
+
+			vec3 prevBonePos = AnimList->PrevBoneList[nBone].Pos;
+
+			px = PrevPos - prevBonePos;
+
+			px = inv_q * (q0 * vec4(px) * inv_q0) * q;
+			
+			vec3 bonePos = AnimList->BoneList[nBone].Pos;
+
+			p[j] = bonePos + px;
+		
+		}
+
+		px = vec3(0.0f, 0.0f, 0.0f);
+
+		for (j=0; j<weightCount; j++)
+		{
+			px += p[j] * AnimList->VertexWeightList[i].VertexBoneInfo[j].BoneWeight;
+		}
+
+		//LiteModel.VertexArr[i] = px;
+		LiteModel.TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i] = px;
+
+		/*
+		//Normal
+		px = ((vec3*)(LiteModel.TrianglePointer))[i+VertexCount]; 
+		px = dR * px;
+		((vec3*)(LiteModel.TrianglePointer))[i+VertexCount] = px;
+
+		//Tangent
+		px = ((vec3*)(LiteModel.TrianglePointer))[i+VertexCount+VertexCount]; 
+		px = dR * px;
+		((vec3*)(LiteModel.TrianglePointer))[i+VertexCount+VertexCount] = px;
+
+		//Binormal
+		px = ((vec3*)(LiteModel.TrianglePointer))[i+VertexCount+VertexCount+VertexCount]; 
+		px = dR * px;
+		((vec3*)(LiteModel.TrianglePointer))[i+VertexCount+VertexCount+VertexCount] = px;*/
+	}
+	
+}
+
+void TAnimModel::SaveVertexInfoToBuf() 
+{
+
+	CopyVertexArr = LiteModel.TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB];
+
+	AnimList->SaveBoneSystemToBuf(); 
+}
+void TAnimModel::LoadVertexInfoFromBuf() 
+{  
+
+	LiteModel.TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB] = CopyVertexArr;
+
+	AnimList->LoadBoneSystemFromBuf(); 
+}
+
+
+bool TAnimModel::LoadModel(const std::string& modelName)
+{
+	if (!LiteModel.LoadModel(modelName))
+		return false;
+
+
+	CopyVertexArr.resize(LiteModel.TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size());
+	CopyVertexArr = LiteModel.TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB];
+
+	AnimList = ResourceManager->ModelAnimManager[modelName];
+
+	if (AnimList == NULL)
+		return false;
+
+	Ready = true;
+
+	SaveVertexInfoToBuf();
+	
+	return true;
+}
+
+void TAnimModel::Clear()
+{
+	
+	CopyVertexArr.clear();
+
+	LiteModel.FreeModel();
+	AnimList = NULL;
+
+	Ready = false;
+}
+
+void TAnimModel::ScaleModel(float s)
+{
+	LiteModel.ScaleModel(s);
+	AnimList->ScaleAnimList(s);
+
+	SaveVertexInfoToBuf();
+}
+
+void TAnimModel::MoveModel(const vec3& v)
+{
+	LiteModel.MoveModel(v);
+	AnimList->MoveAnimList(v);
+
+	SaveVertexInfoToBuf();
+}
+
+void TAnimModel::RotateModel(const mat3& r)
+{
+	LiteModel.RotateModel(r);
+	AnimList->RotateAnimList(r);
+
+	SaveVertexInfoToBuf();
+}
+
+void TAnimModel::DrawImmediate()
+{
+	LiteModel.DrawImmediate();
+}
+
+void TAnimModel::ApplySequence(const std::string& seq, int n)
+{
+	
+	int boneCount = AnimList->BoneList.size();
+
+	for (int i=0; i<boneCount; i++)
+	{
+		AnimList->BoneList[i].Pos = AnimList->AnimSequenceMap[seq].BoneInfoMatrix[n][i].Pos;
+		AnimList->BoneList[i].Quat = AnimList->AnimSequenceMap[seq].BoneInfoMatrix[n][i].Quat;
+		AnimList->BoneList[i].Len  = AnimList->AnimSequenceMap[seq].BoneInfoMatrix[n][i].Len;
+	}
+
+	RecalcVertexPos();
+}
+
+} //namespace SE

src/ApplicationInterface.cpp

@@ -0,0 +1,35 @@
+#include "include/Engine.h"
+
+
+namespace SE
+{
+
+TApplicationInterface::TApplicationInterface()
+	: IsConsoleOut(false) 
+{
+}
+
+void TApplicationInterface::OuterInit(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+	ResourceManager->ScriptManager.BindBasicFunctions();
+	InnerInit();
+#ifdef TARGET_HALIBUT
+	Renderer->InitOpenGL(screenWidth, screenHeight, matrixWidth, matrixHeight);
+#endif
+#ifdef TARGET_SALMON
+	Renderer->InitOpenGL(screenWidth, screenHeight, matrixWidth, matrixHeight);
+#endif
+    
+    CheckGlError();
+    
+    srand(static_cast<unsigned int>(time(0)));
+}
+
+void TApplicationInterface::OuterDeinit()
+{
+	CheckGlError("OuterDeinit");
+	InnerDeinit();
+}
+
+
+} //namespace SE

src/FontManager/FontManager.cpp

@@ -0,0 +1,479 @@
+#include "include/FontManager/FontManager.h"
+#include "include/Engine.h"
+
+#include <boost/algorithm/string.hpp>
+
+namespace SE
+{
+
+const float CONST_HEIGHT_COEF = 1.0f;
+
+const int CONST_MAX_FONT_STACK_SIZE = 10;
+
+
+
+TFontManager::~TFontManager()
+{
+	*Console<<"TFontManager deleting...";
+}
+
+void TFontManager::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Fonts"))
+	{
+	
+		std::string fontName = v.second.get<std::string>("FontName");
+		std::string bitmapFileName = v.second.get<std::string>("BitmapFileName");
+		std::string charmapFileName = v.second.get<std::string>("CharmapFileName");
+
+		AddFont(fontName, bitmapFileName, charmapFileName);
+
+	}
+
+}
+
+void TFontManager::AddFont(const std::string& fontName, const std::string& bitmapFile, const std::string&  charmapFile)
+{
+	if (FontMap.count(fontName) > 0)
+	{
+		throw ErrorToLog("Trying to add font twice or some font files not found!" + fontName);
+	}
+
+	TFont& currentFont = FontMap[fontName];
+
+	std::string texName = GetFileName(bitmapFile);
+
+	currentFont.TexName = texName;
+
+	ResourceManager->TexList.AddTexture(bitmapFile);
+
+	currentFont.SheetWidth = ResourceManager->TexList.GetTextureWidth(texName);
+	currentFont.SheetHeight = ResourceManager->TexList.GetTextureHeight(texName);
+
+	cardinal byteCount;
+
+	boost::shared_array<char> charmapFileArr = boost::shared_array<char>(CreateMemFromFile<char>(ResourceManager->PathToResources+charmapFile, byteCount));
+
+	//Need to rewrite this code :(
+
+	TFontParams fontParams;
+	cardinal character;
+
+	std::stringstream charmapFileStream;
+	charmapFileStream.write(&charmapFileArr[0], byteCount);
+
+	while(!charmapFileStream.eof())
+	{
+
+		charmapFileStream>>character;
+		charmapFileStream>>fontParams.ShiftX;
+		charmapFileStream>>fontParams.ShiftY;
+		charmapFileStream>>fontParams.InternalShiftX;
+		charmapFileStream>>fontParams.InternalShiftY;
+		charmapFileStream>>fontParams.BitmapWidth;
+		charmapFileStream>>fontParams.BitmapHeight;
+		charmapFileStream>>fontParams.Advance;
+
+		currentFont.CharMap[character] = fontParams;
+	}
+
+
+	
+}
+	
+
+
+void TFontManager::PushFont(const std::string& fontName)
+{
+	if (FontStack.size() >= CONST_MAX_FONT_STACK_SIZE)
+	{
+		throw ErrorToLog("Error: font stack overflow!");
+	}
+	FontStack.push(fontName);
+}
+
+void TFontManager::PopFont()
+{
+	if (FontStack.size() == 0)
+	{
+		throw ErrorToLog("Error: font stack underflow!");
+	}
+
+	FontStack.pop();
+}
+
+std::string TFontManager::GetCurrentFontName()
+{
+	if (FontStack.size() == 0)
+	{
+		throw ErrorToLog("Error: font stack underflow!");
+	}
+
+	return FontStack.top();
+}
+
+std::string TFontManager::GetCurrentFontTextureName()
+{
+	return FontMap[GetCurrentFontName()].TexName;
+}
+
+
+float TFontManager::DrawChar(vec2 pos, cardinal character)
+{
+	//Also see DrawCharToVBO
+
+	std::string fontName = GetCurrentFontName();
+
+	if (FontMap.count(fontName) == 0)
+	{
+		throw ErrorToLog("Trying to use unknown font! " + fontName);
+	}
+
+	TFont& currentFont = FontMap[fontName];
+
+	TFontParams& fontParams = currentFont.CharMap[character];
+
+	int scale_y = currentFont.SheetHeight;
+	int scale_x = currentFont.SheetWidth;
+
+	float height = scale_y*fontParams.BitmapHeight;
+
+	float width = scale_x*fontParams.BitmapWidth;
+
+	vec2 p1 = pos + vec2(+ scale_x*fontParams.InternalShiftX, -height- scale_y*fontParams.InternalShiftY);
+	vec2 p2 = pos + vec2(width + scale_x*fontParams.InternalShiftX, - scale_y* fontParams.InternalShiftY);
+	
+	vec2 t1 = vec2(fontParams.ShiftX,
+		1 - fontParams.ShiftY - fontParams.BitmapHeight - fontParams.InternalShiftY);
+	vec2 t2 = vec2(fontParams.ShiftX + fontParams.BitmapWidth, 
+		1 - fontParams.ShiftY - fontParams.InternalShiftY);
+	
+	Renderer->DrawRect(p1, p2, t1, t2);
+
+	return fontParams.Advance*scale_x;
+}
+
+float TFontManager::DrawCharToVBO(vec2 pos, cardinal character, TTriangleList& triangleList)
+{
+	//Also see DrawChar
+
+	std::string fontName = GetCurrentFontName();
+
+	if (FontMap.count(fontName) == 0)
+	{
+		throw ErrorToLog("Trying to use unknown font! " + fontName);
+	}
+
+	TFont& currentFont = FontMap[fontName];
+
+	TFontParams& fontParams = currentFont.CharMap[character];
+
+	int scale_y = currentFont.SheetHeight;
+	int scale_x = currentFont.SheetWidth;
+
+	float height = scale_y*fontParams.BitmapHeight;
+
+	float width = scale_x*fontParams.BitmapWidth;
+	
+	vec2 p1 = pos + vec2(+ scale_x*fontParams.InternalShiftX, -height - scale_y*fontParams.InternalShiftY);
+	vec2 p2 = pos + vec2(width + scale_x*fontParams.InternalShiftX, - scale_y* fontParams.InternalShiftY);
+
+	
+	vec2 t1 = vec2(fontParams.ShiftX,
+		1 - fontParams.ShiftY - fontParams.BitmapHeight - fontParams.InternalShiftY);
+	vec2 t2 = vec2(fontParams.ShiftX + fontParams.BitmapWidth, 
+		1 - fontParams.ShiftY - fontParams.InternalShiftY);
+
+	/*
+	vec2 p12 = vec2(p1.v[0], p2.v[1]);
+	vec2 p21 = vec2(p2.v[0], p1.v[1]);
+
+	vec2 t12 = vec2(t1.v[0], t2.v[1]);
+	vec2 t21 = vec2(t2.v[0], t1.v[1]);
+	
+	
+	triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(vec3(p1, 0));
+	triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(vec3(p12, 0));
+	triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(vec3(p2, 0));
+
+	triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(vec3(p2, 0));
+	triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(vec3(p21, 0));
+	triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(vec3(p1, 0));
+
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(t1);
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(t12);
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(t2);
+
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(t2);
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(t21);
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].push_back(t1);
+	*/
+	triangleList.Data += MakeDataTriangleList(p1, p2, t1, t2);
+	
+	return fontParams.Advance*scale_x;
+}
+
+vec2 TFontManager::FitStringToBox(vec2 posFrom, vec2 posTo, TTextBasicAreaParams params, std::string& str)
+{
+	//Need to make this deprecated!
+    
+    throw ErrorToLog("Call to deprecated TFontManager::FitStringToBox");
+    
+	std::string fontName = GetCurrentFontName();
+
+	float intervalY = CONST_HEIGHT_COEF * params.Height;
+
+	size_t rows = 1;
+
+	float maxWidth = posTo.v[0] - posFrom.v[0];
+
+	cardinal p = 0;
+	vec2 cursor;
+
+	while (p<str.size())
+	{
+		char c = str[p];
+		
+		if (c == '\n')
+		{
+			cursor.v[0] = 0;
+		}
+		else
+		{
+			cursor.v[0] += GetCharAdvance(c);
+		}
+		if (cursor.v[0] > maxWidth)
+		{
+			str.insert(p, 1, '\n');
+			cursor.v[0] = 0;
+		}
+
+		p++;
+	}
+
+	size_t found = str.find_first_of('\n');
+	
+	while (found != std::string::npos)
+	{
+		rows++;
+		found = str.find_first_of('\n', found + 1);
+	}
+
+	return vec2(posFrom.v[0], posFrom.v[1] + intervalY*rows);
+
+}
+
+
+vec2 TFontManager::FitStringToBoxWithWordWrap(vec2 posFrom, vec2 posTo, TTextBasicAreaParams params, std::string& str)
+{
+
+	std::string fontName = GetCurrentFontName();
+
+	float intervalY = CONST_HEIGHT_COEF * params.Height;
+
+	size_t rows = 1;
+    
+    //Apply padding:
+    
+    posFrom.v[0] += params.HorizontalPadding;
+    posTo.v[0] -= params.HorizontalPadding;
+    posFrom.v[1] += params.VerticalPadding;
+    posTo.v[1] -= params.VerticalPadding;
+    
+
+	float maxWidth = posTo.v[0] - posFrom.v[0];
+
+
+	//cardinal p = 0;
+	vec2 cursor;
+
+
+	std::vector<std::string> explodedByParagraph;
+
+	boost::split(explodedByParagraph, str, boost::is_any_of("\n"), boost::token_compress_on);
+
+	std::string result;
+
+
+	for (size_t i=0; i<explodedByParagraph.size(); i++)
+	{
+		std::vector<std::string> explodedByWord;
+
+		boost::split(explodedByWord, explodedByParagraph[i], boost::is_space(), boost::token_compress_on);
+
+		for (size_t j=0; j< explodedByWord.size(); j++)
+		{
+			std::string s = explodedByWord[j];
+
+			float adv = GetTextAdvance(s);
+
+			if (adv + cursor.v[0] < maxWidth)
+			{
+				result += s + " ";
+				cursor.v[0] += adv + GetCharAdvance(' ');
+			}
+			else
+			{
+				if (adv < maxWidth)
+				{
+					result += "\n" + s + " "; 
+					cursor.v[0] = adv + GetCharAdvance(' ');
+				}
+				else
+				{
+					for (int k=0; k<s.size(); k++)
+					{
+						result += s[k];
+						cursor.v[0] += GetCharAdvance(s[k]);
+						if (cursor.v[0] > maxWidth)
+						{
+							cursor.v[0] = 0;
+							result += "\n";
+						}
+					}
+				}
+			}
+		}
+
+		result += "\n";
+		cursor.v[0] = 0;
+
+	}
+
+	//Erase last symbol \n
+	result.erase(result.end()-1, result.end());
+
+
+	str = result;
+
+	size_t found = str.find_first_of('\n');
+	
+	while (found != std::string::npos)
+	{
+		rows++;
+		found = str.find_first_of('\n', found + 1);
+	}
+    
+    vec2 result_vec = vec2(posFrom.v[0], posFrom.v[1] + intervalY*rows);
+    
+    if (params.TextHorizontalAlignment == THA_RIGHT)
+    {
+        result_vec.v[0] = posTo.v[0];
+    }
+    else if (params.TextHorizontalAlignment == THA_CENTER)
+    {
+        result_vec.v[0] = (posTo.v[0] + posFrom.v[0])*0.5f;
+    }
+    
+    if (params.TextVerticalAlignment == TVA_TOP)
+    {
+        result_vec.v[1] = posTo.v[1];
+    }
+    else if (params.TextVerticalAlignment == TVA_CENTER)
+    {
+        result_vec.v[1] = (posTo.v[1] + posFrom.v[1])*0.5f;
+    }
+
+	return result_vec;
+
+}
+
+TTriangleList TFontManager::DrawStringToVBO(vec2 pos, TTextBasicAreaParams params, const std::string& str)
+{
+
+	std::wstring ws;
+	utf8toWStr(ws, str);
+
+	std::string fontName = GetCurrentFontName();
+
+	float width;
+
+	TTriangleList triangleList;
+    
+    std::vector<std::wstring> rowArr;
+    
+    boost::split(rowArr, ws, boost::algorithm::is_any_of("\n"));
+
+	vec2 startPos = pos;
+    
+    float rowsHeight = rowArr.size() * CONST_HEIGHT_COEF*params.Height;
+    
+	
+    BOOST_FOREACH(auto& rowStr, rowArr)
+    {
+        
+        float rowWidth = GetTextAdvance(rowStr);
+        
+        for (cardinal i=0; i<rowStr.size(); i++)
+        {
+            vec2 realPos = pos;
+            if (params.TextHorizontalAlignment == THA_RIGHT)
+            {
+                realPos.v[0] = realPos.v[0] - rowWidth;
+            }
+            else if (params.TextHorizontalAlignment == THA_CENTER)
+            {
+                realPos.v[0] = realPos.v[0] - rowWidth*0.5f;
+				realPos.v[0] = floorf(realPos.v[0]);
+            }
+            
+            if (params.TextVerticalAlignment == TVA_CENTER)
+            {
+                realPos.v[1] = realPos.v[1] + rowsHeight*0.5f;
+				realPos.v[1] = floorf(realPos.v[1]);
+            }
+            
+            width = DrawCharToVBO(realPos, rowStr[i], triangleList);
+            
+            pos += vec2(width, 0);
+        }
+        
+        pos.v[1] -= CONST_HEIGHT_COEF*params.Height;
+        pos.v[0] = startPos.v[0];
+    }
+
+	triangleList.RefreshBuffer();
+
+	return triangleList;
+}
+	
+
+void TFontManager::DrawString(vec2 pos, TTextBasicAreaParams params, const std::string& str)
+{
+	TTriangleList triangleList = DrawStringToVBO(pos, params, str);
+
+	Renderer->DrawTriangleList(triangleList);
+
+}
+
+void TFontManager::DrawTextInBox(vec2 posFrom, vec2 posTo, TTextBasicAreaParams params, std::string str, bool wordWrap)
+{
+	vec2 realPosFrom;
+	if (wordWrap)
+	{
+		realPosFrom = FitStringToBoxWithWordWrap(posFrom, posTo, params, str);
+	}
+	else
+	{
+		realPosFrom = FitStringToBox(posFrom, posTo, params, str);
+	}
+
+	DrawString(realPosFrom, params, str);
+}
+
+TTriangleList TFontManager::DrawTextInBoxToVBO(vec2 posFrom, vec2 posTo, TTextBasicAreaParams params, std::string str, bool wordWrap)
+{
+
+	vec2 realPosFrom;
+	if (wordWrap)
+	{
+		realPosFrom = FitStringToBoxWithWordWrap(posFrom, posTo, params, str);
+	}
+	else
+	{
+		realPosFrom = FitStringToBox(posFrom, posTo, params, str);
+	}
+	return DrawStringToVBO(realPosFrom, params, str);
+}
+
+} //namespace SE

src/FrameManager/FrameManager.cpp

@@ -0,0 +1,341 @@
+#include "include/FrameManager/FrameManager.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+//===================================================
+//================ FRAME MANAGER ====================
+//===================================================
+
+
+TFrameManager::~TFrameManager()
+{
+	FreeFrameManager();
+	*Console<<"ResourceManager::FrameManager deleting"; 
+}
+
+void TFrameManager::FreeFrameManager()
+{
+    BOOST_FOREACH(auto& i, FrameMap)
+	{
+		ResourceManager->TexList.DeleteTexture(i.second.TexName);
+		glDeleteRenderbuffers(1, &(i.second.DepthRenderBuffer));
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+		glDeleteFramebuffers(1, &(i.second.FrameBuffer));
+	}
+
+	FrameMap.clear();
+
+}
+
+cardinal TFrameManager::AddFrameRenderBuffer(const std::string& frameName,cardinal width,cardinal height)
+{
+	#ifdef TARGET_ANDROID
+	#define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
+	#endif
+    #ifdef TARGET_IOS
+    #define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
+    #endif
+	
+	if (FrameMap.count(frameName) == 0)
+	{
+
+		
+		
+		std::string texName = frameName + "Texture";
+		cardinal texID = ResourceManager->TexList.AddEmptyTexture(texName,width,height);
+	
+		
+		cardinal frameBuffer;
+		cardinal depthRenderBuffer;
+		cardinal status;
+
+
+		glGenFramebuffers(1,&frameBuffer);
+		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
+		
+		
+		glGenRenderbuffers(1, &depthRenderBuffer);
+		glBindRenderbuffer(GL_RENDERBUFFER, depthRenderBuffer);
+		
+		#ifdef TARGET_WIN32
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
+		#endif
+		#ifdef TARGET_ANDROID
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+		#endif
+        #ifdef TARGET_IOS
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+        #endif
+		
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderBuffer);
+
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texID, 0);
+		
+		status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		
+		switch(status)
+		{
+		case GL_FRAMEBUFFER_COMPLETE_EXT:
+			*Console<<"FrameManager:: frame buffer added: "+frameName;
+			FrameMap[frameName].FrameBuffer = frameBuffer;
+			FrameMap[frameName].DepthRenderBuffer = depthRenderBuffer;
+			FrameMap[frameName].TexID = texID;
+			FrameMap[frameName].Width = width;
+			FrameMap[frameName].Height = height;
+			FrameMap[frameName].TexName = texName;
+			
+			return FrameMap[frameName].FrameBuffer;
+
+			break;
+		default:
+			*Console<<"FrameManager::ERROR - frame buffer can not be added correctly: "+frameName+", with error: "+tostr(status);
+			ResourceManager->TexList.DeleteTexture(texName);
+			glDeleteRenderbuffers(1, &depthRenderBuffer);
+			glBindFramebuffer(GL_FRAMEBUFFER, 0);
+			glDeleteFramebuffers(1, &frameBuffer);
+
+			return 0;
+		}
+		
+	}
+	else
+		return FrameMap[frameName].FrameBuffer;
+
+	#ifdef TARGET_ANDROID
+	#undef GL_FRAMEBUFFER_COMPLETE_EXT
+	#endif
+    #ifdef TARGET_IOS
+    #undef GL_FRAMEBUFFER_COMPLETE_EXT
+    #endif
+    
+}
+
+cardinal TFrameManager::AddCubemapBuffer(const std::string& frameName,cardinal width,cardinal height)
+{
+
+	#ifdef TARGET_ANDROID
+	#define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
+	#endif
+    #ifdef TARGET_IOS  
+    #define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
+    #endif
+	
+	if (FrameMap.count(frameName) == 0)
+	{
+
+		std::string texName = frameName + "Texture";
+		cardinal texID = ResourceManager->TexList.AddEmptyCubemapTexture(texName,width,height);
+
+		cardinal frameBuffer;
+		cardinal depthRenderBuffer;
+		cardinal status;
+
+
+		glGenFramebuffers(1,&frameBuffer);
+		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
+
+		glGenRenderbuffers(1, &depthRenderBuffer);
+		glBindRenderbuffer(GL_RENDERBUFFER, depthRenderBuffer);
+		
+		#ifdef TARGET_WIN32
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
+		#endif
+		#ifdef TARGET_ANDROID
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+		#endif
+        #ifdef TARGET_IOS
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+        #endif
+		
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderBuffer);
+
+
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, texID, 0);
+
+		//?? is it needed?
+		
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+1, texID, 0);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+2, texID, 0);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+3, texID, 0);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+4, texID, 0);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+5, texID, 0);
+
+
+
+
+		status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+		switch(status)
+		{
+		case GL_FRAMEBUFFER_COMPLETE_EXT:
+			*Console<<"FrameManager:: frame buffer added: "+frameName;
+			FrameMap[frameName].FrameBuffer = frameBuffer;
+			FrameMap[frameName].DepthRenderBuffer = depthRenderBuffer;
+			FrameMap[frameName].TexID = texID;
+			FrameMap[frameName].Width = width;
+			FrameMap[frameName].Height = height;
+			FrameMap[frameName].TexName = texName;
+
+			//return FrameMap[frameName].TexID; //That is easier
+			return FrameMap[frameName].FrameBuffer;
+
+			break;
+		default:
+			*Console<<"ERROR number : "+tostr(status)+endl;
+			*Console<<"FrameManager::ERROR - frame buffer can not be added correctly: "+frameName;
+			ResourceManager->TexList.DeleteTexture(texName);
+			glDeleteRenderbuffers(1, &depthRenderBuffer);
+			glBindFramebuffer(GL_FRAMEBUFFER, 0);
+			glDeleteFramebuffers(1, &frameBuffer);
+
+			return 0;
+		}
+
+
+	}
+	else
+		return FrameMap[frameName].FrameBuffer;
+		
+	#ifdef TARGET_ANDROID
+	#undef GL_FRAMEBUFFER_COMPLETE_EXT
+	#endif
+    #ifdef TARGET_IOS
+    #undef GL_FRAMEBUFFER_COMPLETE_EXT
+    #endif
+
+}
+
+void TFrameManager::DeleteFrameRenderBuffer(const std::string& frameName)
+{
+	if (FrameMap.count(frameName) > 0)
+	{
+		ResourceManager->TexList.DeleteTexture(FrameMap[frameName].TexName);
+		glDeleteRenderbuffers(1, &(FrameMap[frameName].DepthRenderBuffer));
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+		glDeleteFramebuffers(1, &(FrameMap[frameName].FrameBuffer));
+
+		FrameMap.erase(frameName);
+	}
+}
+
+cardinal TFrameManager::AddDepthBuffer(const std::string& frameName, cardinal width, cardinal height)
+{
+
+	#ifdef TARGET_ANDROID
+	#define GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_COMPLETE
+	#endif
+	
+	if (FrameMap.count(frameName) == 0)
+	{
+
+		std::string texName = frameName + "Texture";
+		cardinal depthTexID = ResourceManager->TexList.AddDepthTexture(texName,width,height);
+
+		cardinal frameBuffer;
+		cardinal status;
+
+
+		glGenFramebuffers(1,&frameBuffer);
+		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
+
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTexID, 0);
+		
+		#ifdef TARGET_WIN32
+		glDrawBuffer(GL_NONE);
+		glReadBuffer(GL_NONE);
+		#endif
+		
+		status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+		switch(status)
+		{
+		case GL_FRAMEBUFFER_COMPLETE:
+			*Console<<"FrameManager:: frame buffer added: "+frameName;
+			FrameMap[frameName].FrameBuffer = frameBuffer;
+			FrameMap[frameName].DepthRenderBuffer = 0;
+			FrameMap[frameName].TexID = depthTexID;
+			FrameMap[frameName].Width = width;
+			FrameMap[frameName].Height = height;
+			FrameMap[frameName].TexName = texName;
+
+			return FrameMap[frameName].FrameBuffer;
+			break;
+		default:
+			*Console<<"FrameManager::ERROR - frame buffer can not be added correctly: "+frameName;
+			ResourceManager->TexList.DeleteTexture(texName);
+			glBindFramebuffer(GL_FRAMEBUFFER, 0);
+			glDeleteFramebuffers(1, &frameBuffer);
+
+			return 0;
+		}
+
+
+	}
+	else
+		return FrameMap[frameName].FrameBuffer;
+		
+	#ifdef TARGET_ANDROID
+	#undef GL_FRAMEBUFFER_COMPLETE_EXT
+	#endif
+}
+
+
+
+cardinal TFrameManager::GetFrameTexture(const std::string& frameName)
+{
+	if (FrameMap.count(frameName) > 0)
+	{
+		return FrameMap[frameName].TexID;
+	}
+	else
+		return 0;
+}
+
+
+ivec2 TFrameManager::GetFrameWidthHeight(const std::string& frameName)
+{
+	if (FrameMap.count(frameName) == 0)
+	{
+		throw ErrorToLog("Frame "+frameName+" not found!");
+	}
+
+	return ivec2(FrameMap[frameName].Width, FrameMap[frameName].Height);
+}
+
+
+TTextureData TFrameManager::ReadFromBufferToTexData(const std::string& frameName)
+{
+	TTextureData texData;
+	texData.Width = FrameMap[frameName].Width;
+	texData.Height = FrameMap[frameName].Height;
+	texData.DataSize = texData.Width * texData.Height * 3;
+
+	texData.Data = boost::shared_array<char>(new char[texData.DataSize]);
+
+	boost::shared_array<char> data(new char[texData.Width * texData.Height * 4]);
+
+	glReadPixels(0, 0, FrameMap[frameName].Width, FrameMap[frameName].Height, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
+
+	for (cardinal i=0; i < texData.Width; i++)
+	{
+		for (cardinal j=0; j < texData.Height; j++)
+		{
+			int x = (i * texData.Height + j) + (i * texData.Height + j) + (i * texData.Height + j);
+
+			int y = 4 * (i * texData.Height + j);
+
+			texData.Data[x + 2] = data[y + 2];
+			texData.Data[x + 1] = data[y + 1];
+			texData.Data[x + 0] = data[y + 0];
+		}
+	}
+
+	return texData;
+
+}
+
+} //namespace SE

src/GUIManager/GUIManager.cpp

@@ -0,0 +1,415 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+const std::string CONST_HOLD_SIGNAL_NAME = "OnHold";
+const std::string CONST_CLICK_SIGNAL_NAME = "OnClick";
+const std::string CONST_DRAG_SIGNAL_NAME = "OnDrag";
+
+
+TGUIManager::~TGUIManager()
+{
+
+	WidgetTrasfromTaskList.clear();
+
+	WidgetArr.clear();
+
+	*Console<<"GUI Manager deleting...";
+}
+
+
+void TGUIManager::AddWidget(std::shared_ptr<TInstancingWidgetAncestor> widgetAncestor, const std::string& name, const std::string& groupName, int order)
+{
+	for (TWidgetArr::iterator i = WidgetArr.begin(); i != WidgetArr.end(); i++)
+	{
+		if (i->Name == name)
+		{
+			return;
+		}
+	}
+	WidgetArr.push_back(TWidgetStruct(name, groupName, widgetAncestor, order));
+	std::stable_sort(WidgetArr.begin(), WidgetArr.end());
+}
+
+void TGUIManager::DeleteWidget(std::string name)
+{
+	for (TWidgetArr::iterator i = WidgetArr.begin(); i != WidgetArr.end(); i++)
+	{
+		if (i->Name == name)
+		{
+			WidgetArr.erase(i);
+			return;
+		}
+	}
+}
+
+void TGUIManager::DeleteWidgetGroup(std::string groupName)
+{
+	bool widgetErased;
+	for (TWidgetArr::iterator i = WidgetArr.begin(); i != WidgetArr.end();)
+	{
+		widgetErased = false;
+		if (i->GroupName == groupName)
+		{
+			i = WidgetArr.erase(i);
+			widgetErased = true;
+		}
+
+		if (i != WidgetArr.end() & !widgetErased)
+		{
+			++i;
+		}
+	}
+}
+
+void TGUIManager::DeleteWidgetOnUpdate(const std::string& name)
+{
+	PostUpdateSignal.connect(boost::bind(&TGUIManager::DeleteWidget, this, name));
+}
+
+void TGUIManager::DeleteWidgetGroupOnUpdate(const std::string& groupName)
+{
+	PostUpdateSignal.connect(boost::bind(&TGUIManager::DeleteWidgetGroup, this, groupName));
+}
+
+
+
+void TGUIManager::AddWidgetTransformTask(TWidgetTransformTask widgetTransformTask)
+{
+	WidgetTrasfromTaskList.push_back(widgetTransformTask);
+}
+
+void TGUIManager::Update(cardinal dt)
+{
+
+	WidgetListMutex.lock();
+
+	for (TWidgetArr::iterator i = WidgetArr.begin(); i != WidgetArr.end(); ++i)
+	{
+		i->Widget->Update(dt);
+
+		if (i->IsMouseDown)
+		{
+			(*(i->SignalMap[CONST_HOLD_SIGNAL_NAME]))(TSignalParam(dt));
+
+		}
+		
+		for (TRenderPairList::iterator itr = i->Widget->TriangleListVector.begin(); itr != i->Widget->TriangleListVector.end(); ++itr)
+		{
+			if (itr->second.NeedRefreshBuffer)
+			{
+				itr->second.RefreshBuffer();
+				itr->second.NeedRefreshBuffer = false;
+			}
+		}
+	}
+
+	for (TWidgetTrasfromTaskList::iterator i = WidgetTrasfromTaskList.begin(); i != WidgetTrasfromTaskList.end(); )
+	{
+		int prevCurrentTime = i->CurrentTime;
+
+		i->CurrentTime += dt;
+
+		if (i->CurrentTime >= i->TotalTime)
+		{
+			i->CurrentTime = i->TotalTime;
+		}
+
+		vec2 oldPos;
+		vec2 newPos;
+
+		float t0 = clamp<float>((prevCurrentTime + 0.f)/i->TotalTime, 0, 1);
+		float t = clamp<float>((i->CurrentTime + 0.f)/i->TotalTime, 0, 1);
+
+		if (i->MoveStyle == TWidgetTransformTask::MS_LINEAR)
+		{
+			oldPos = InterpolateLinear<vec2>(vec2(0,0), i->PosTo, t0);
+			newPos = InterpolateLinear<vec2>(vec2(0,0), i->PosTo, t);
+		}
+		if (i->MoveStyle == TWidgetTransformTask::MS_SQR)
+		{
+			oldPos = InterpolateSqr<vec2>(vec2(0,0), i->PosTo, t0);
+			newPos = InterpolateSqr<vec2>(vec2(0,0), i->PosTo, t);
+		}
+		if (i->MoveStyle == TWidgetTransformTask::MS_SQRT)
+		{
+			oldPos = InterpolateSqrt<vec2>(vec2(0,0), i->PosTo, t0);
+			newPos = InterpolateSqrt<vec2>(vec2(0,0), i->PosTo, t);
+		}
+
+		vec2 moveDistance = newPos - oldPos;
+
+		for (TWidgetArr::iterator j = WidgetArr.begin(); j != WidgetArr.end(); ++j)
+		{
+			if (j->GroupName == i->GroupName)
+			{
+				MoveWidgetByIterator(j, moveDistance);
+			}
+		}
+
+
+		if (i->CurrentTime == i->TotalTime)
+		{
+			i = WidgetTrasfromTaskList.erase(i);
+		}
+		else
+		{
+			++i;
+		}
+	}
+
+	WidgetListMutex.unlock();
+
+	PostUpdateSignal();
+
+	PostUpdateSignal.disconnect_all_slots();
+}
+
+void TGUIManager::Draw()
+{
+	
+	TWidgetArr::iterator i;
+	for (i = WidgetArr.begin(); i != WidgetArr.end(); ++i)
+	{
+
+		TRenderPairList::iterator j;
+		
+		for (j = i->Widget->TriangleListVector.begin(); j != i->Widget->TriangleListVector.end(); ++j)
+		{
+
+			TRenderParamsSetter paramSetter(j->first);
+
+			Renderer->DrawTriangleList(j->second);
+
+			CheckGlError("TGUIManager::Draw()");
+
+		}
+	}
+}
+
+TWidgetArr::iterator TGUIManager::FindWidgetInArr(const std::string& widgetName)
+{
+	TWidgetArr::iterator i;
+
+	for (i = WidgetArr.begin(); i != WidgetArr.end(); ++i)
+	{
+		if (i->Name == widgetName)
+		{
+			break;
+		}
+	}
+
+	if (i == WidgetArr.end())
+	{
+		throw ErrorToLog("ERROR: widget not found: "+widgetName);
+	}
+
+	return i;
+}
+
+void TGUIManager::MoveWidgetByIterator(TWidgetArr::iterator widget, vec2 shift)
+{
+	widget->Widget->LeftBottomPos += shift;
+
+	std::vector<vec3>::iterator i;
+
+	TRenderPairList::iterator itr;
+
+	for (itr = widget->Widget->TriangleListVector.begin(); itr != widget->Widget->TriangleListVector.end(); ++itr)
+	{
+		std::vector<vec3>& vertexCoordVec = itr->second.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB];
+
+		for (i = vertexCoordVec.begin(); i != vertexCoordVec.end(); ++i)
+		{
+			*i += vec3(shift, 0);
+		}
+
+		itr->second.NeedRefreshBuffer = true;
+	}
+}
+
+void TGUIManager::MoveWidget(const std::string& widgetName, vec2 shift)
+{
+	
+	TWidgetArr::iterator widget = FindWidgetInArr(widgetName);
+	MoveWidgetByIterator(widget, shift);
+}
+
+void TGUIManager::MoveWidgetGroup(const std::string& widgetGroupName, const std::string& exceptWidget, vec2 shift)
+{
+	for (TWidgetArr::iterator i = WidgetArr.begin(); i != WidgetArr.end(); ++i)
+	{
+		if (i->GroupName == widgetGroupName && i->Name != exceptWidget)
+		{
+			MoveWidgetByIterator(i, shift);
+		}
+	}
+}
+
+void TGUIManager::OnMouseDown(vec2 pos)
+{
+	//Xperimental - need to call widget methods and signals	NOT IN "FOR" LOOP
+
+	WidgetListMutex.lock();
+
+	TWidgetArr::reverse_iterator i;
+
+	LastTapPos = pos;
+	TotalShift = vec2(0,0);
+
+	for (i = WidgetArr.rbegin(); i != WidgetArr.rend(); ++i)
+	{
+		if (i->Widget->CheckClick(pos))
+		{
+			bool isTransparentForInput = i->Widget->IsTransparentForInput();
+
+			i->Widget->OnTapDown(pos);
+			i->IsMouseDown = true;
+			
+			if (! isTransparentForInput)
+			{
+				WidgetListMutex.unlock();
+				return;
+			}
+		}
+	}
+
+	WidgetListMutex.unlock();
+}
+
+void TGUIManager::OnMouseUp(vec2 pos)
+{
+	//Xperimental - need to call widget methods and signals	NOT IN "FOR" LOOP
+
+	WidgetListMutex.lock();
+
+	TWidgetArr::reverse_iterator i;
+
+	for (i = WidgetArr.rbegin(); i != WidgetArr.rend(); ++i)
+	{
+		if (i->Widget->CheckClick(pos))
+		{
+			bool isTransparentForInput = i->Widget->IsTransparentForInput();
+			i->Widget->OnTapUp(pos);
+			i->IsMouseDown = false;
+			(*(i->SignalMap[CONST_CLICK_SIGNAL_NAME]))(TSignalParam(pos));
+			
+			if (! isTransparentForInput)
+			{
+				WidgetListMutex.unlock();
+				return;
+			}
+		}
+	}
+
+	WidgetListMutex.unlock();
+}
+
+void TGUIManager::OnMove(vec2 shift)
+{
+	//Xperimental - need to call widget methods and signals	NOT IN "FOR" LOOP
+
+
+	TWidgetArr::reverse_iterator i;
+
+	bool moveIsProcessed = false;
+	bool moveOutIsProcessed = false;
+
+	TotalShift += shift;
+
+	for (i = WidgetArr.rbegin(); i != WidgetArr.rend(); ++i)
+	{
+		if (!moveIsProcessed && i->Widget->CheckClick(LastTapPos-TotalShift))
+		{
+			bool isTransparentForInput = i->Widget->IsTransparentForInput();
+
+			i->Widget->OnMove(shift);
+			(*(i->SignalMap[CONST_DRAG_SIGNAL_NAME]))(TSignalParam(shift));
+
+			if (! isTransparentForInput)
+			{
+				moveIsProcessed = true;
+			}
+		}
+	}
+
+	for (i = WidgetArr.rbegin(); i != WidgetArr.rend(); ++i)
+	{
+		if (!moveOutIsProcessed && i->Widget->CheckClick(LastTapPos) && !i->Widget->CheckClick(LastTapPos-TotalShift))
+		{
+			bool isTransparentForInput = i->Widget->IsTransparentForInput();
+
+			i->Widget->OnMoveOut();
+			i->IsMouseDown = false;
+			if (! isTransparentForInput)
+			{
+				moveOutIsProcessed = true;
+			}
+		}
+	}
+}
+
+void TGUIManager::PrintWidgetList()
+{
+	TWidgetArr::iterator i;
+
+	for (i = WidgetArr.begin(); i != WidgetArr.end(); ++i)
+	{
+		std::string widgetRow = i->Name + " (" + tostr(i->Widget->LeftBottomPos.v[0]) + ", " + tostr(i->Widget->LeftBottomPos.v[1]) + ")";
+		Console->PrintImmediate(widgetRow);
+	}
+}
+
+
+std::shared_ptr<boost::signal<void (TSignalParam)>> TGUIManager::GetOnClickSignal(const std::string& widgetName)
+{
+
+	TWidgetArr::iterator i = FindWidgetInArr(widgetName);
+
+	return i->SignalMap[CONST_CLICK_SIGNAL_NAME];
+	
+}
+
+std::shared_ptr<boost::signal<void (TSignalParam)>> TGUIManager::GetOnHoldSignal(const std::string& widgetName)
+{
+
+	TWidgetArr::iterator i = FindWidgetInArr(widgetName);
+	
+	return i->SignalMap[CONST_HOLD_SIGNAL_NAME];
+	
+}
+
+std::shared_ptr<boost::signal<void (TSignalParam)>> TGUIManager::GetSignal(const std::string& signalName, const std::string& widgetName)
+{
+
+	TWidgetArr::iterator i = FindWidgetInArr(widgetName);
+	
+	if (i->SignalMap.count(signalName) == 0)
+	{
+		throw ErrorToLog("Illegal signal: "+signalName);
+	}
+
+	return i->SignalMap[signalName];
+}
+
+void TGUIManager::SQ_MoveWidget(const SQChar *widgetName, float x, float y)
+{
+	MoveWidget(std::string(widgetName), vec2(x,y));
+}
+
+
+void TGUIManager::BindFunctions()
+{
+	ResourceManager->ScriptManager.AddFunction("pwl", 
+		TScriptInfo("PrintWidgetList"),
+		ResourceManager->GUIManager,
+		&TGUIManager::PrintWidgetList);
+
+	ResourceManager->ScriptManager.AddFunction("mw", 
+		TScriptInfo("MoveWidget"),
+		ResourceManager->GUIManager,
+		&TGUIManager::SQ_MoveWidget);
+}
+
+} //namespace SE

src/GUIManager/WidgetXmlParsers.cpp

@@ -0,0 +1,514 @@
+#include "include/Engine.h"
+
+
+namespace SE
+{
+
+void TStaticWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	std::string widgetType = propertyTree.get<std::string>("<xmlattr>.type");
+	std::string name = propertyTree.get<std::string>("<xmlattr>.name");
+	std::string group = propertyTree.get<std::string>("<xmlattr>.group");
+
+	float xCenter = propertyTree.get<float>("<xmlattr>.xCenter");
+	float yCenter = propertyTree.get<float>("<xmlattr>.yCenter");
+	float width = propertyTree.get<float>("<xmlattr>.width");
+	float height = propertyTree.get<float>("<xmlattr>.height");
+	int order = propertyTree.get<int>("<xmlattr>.order", 0);
+
+	vec2 posFrom(xCenter - width*0.5f, yCenter - height*0.5f);
+	vec2 posTo(xCenter + width*0.5f, yCenter + height*0.5f);
+
+	//boost::property_tree::ptree& fillerTree = propertyTree.find("Filler")->second;
+
+	std::vector<boost::function<void(TSquareStatic*)>> fillerFuncArr;
+
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		if (v.first == "Filler")
+		{
+			boost::property_tree::ptree& fillerTree = v.second;
+
+			if (fillerTree.get<std::string>("<xmlattr>.type") == "StaticTextureFiller")
+			{
+				std::string normTexName = fillerTree.get<std::string>("<xmlattr>.texName");
+
+				fillerFuncArr.push_back(boost::bind(TSquareStatic::StaticTextureFiller, posFrom, posTo, normTexName, _1));
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "StaticTextFiller")
+			{
+				TTextParams textParamsNormal;
+
+				boost::property_tree::ptree& textParamsNormalTree = fillerTree.find("TextParams")->second;
+
+				textParamsNormal.Serialize(textParamsNormalTree);
+
+				fillerFuncArr.push_back(boost::bind(TSquareStatic::StaticTextFiller, posFrom, posTo, textParamsNormal, _1));
+			}
+		}
+	}
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(TSquareStatic::CreateStaticWithFillers(posFrom, posTo, fillerFuncArr)),
+		name,
+		group,
+		order);
+
+}
+
+
+void TDynamicTextWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	std::string widgetType = propertyTree.get<std::string>("<xmlattr>.type");
+	std::string name = propertyTree.get<std::string>("<xmlattr>.name");
+	std::string group = propertyTree.get<std::string>("<xmlattr>.group");
+
+	float xCenter = propertyTree.get<float>("<xmlattr>.xCenter");
+	float yCenter = propertyTree.get<float>("<xmlattr>.yCenter");
+	float width = propertyTree.get<float>("<xmlattr>.width");
+	float height = propertyTree.get<float>("<xmlattr>.height");
+	int order = propertyTree.get<int>("<xmlattr>.order", 0);
+
+	vec2 posFrom(xCenter - width*0.5f, yCenter - height*0.5f);
+	vec2 posTo(xCenter + width*0.5f, yCenter + height*0.5f);
+
+	//boost::property_tree::ptree& fillerTree = propertyTree.find("Filler")->second;
+
+	std::vector<boost::function<void(TDynamicText*)>> fillerFuncArr;
+
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		if (v.first == "Filler")
+		{
+			boost::property_tree::ptree& fillerTree = v.second;
+
+			if (fillerTree.get<std::string>("<xmlattr>.type") == "TextParamsFiller")
+			{
+				TTextParams textParamsNormal;
+
+				boost::property_tree::ptree& textParamsNormalTree = fillerTree.find("TextParams")->second;
+
+				textParamsNormal.Serialize(textParamsNormalTree);
+
+				fillerFuncArr.push_back(boost::bind(TDynamicText::TextParamsFiller, posFrom, posTo, textParamsNormal, _1));
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "SmartValueTextFiller")
+			{
+				std::string dictionaryName = fillerTree.get<std::string>("<xmlattr>.dictionaryName");
+				std::string smartValueName = fillerTree.get<std::string>("<xmlattr>.smartValueName");
+				fillerFuncArr.push_back(boost::bind(TDynamicText::SmartValueTextFiller, dictionaryName, smartValueName, _1));
+			}
+		}
+	}
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(TDynamicText::CreateDynamicTextWithFillers(posFrom, posTo, fillerFuncArr)),
+		name,
+		group,
+		order);
+
+}
+
+
+
+void TButtonWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+
+	std::string widgetType = propertyTree.get<std::string>("<xmlattr>.type");
+	std::string name = propertyTree.get<std::string>("<xmlattr>.name");
+	std::string group = propertyTree.get<std::string>("<xmlattr>.group");
+
+	float xCenter = propertyTree.get<float>("<xmlattr>.xCenter");
+	float yCenter = propertyTree.get<float>("<xmlattr>.yCenter");
+	float width = propertyTree.get<float>("<xmlattr>.width");
+	float height = propertyTree.get<float>("<xmlattr>.height");
+	int order = propertyTree.get<int>("<xmlattr>.order", 0);
+
+	vec2 posFrom(xCenter - width*0.5f, yCenter - height*0.5f);
+	vec2 posTo(xCenter + width*0.5f, yCenter + height*0.5f);
+
+	std::vector<boost::function<void(TUniversalButton*)> > fillerFuncArr;
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		if (v.first == "Filler")
+		{
+
+			boost::property_tree::ptree& fillerTree = v.second;
+
+			if (fillerTree.get<std::string>("<xmlattr>.type") == "SquareButtonFiller")
+			{
+				std::string normTexName = fillerTree.get<std::string>("<xmlattr>.normTexName");
+				std::string pressedTexName = fillerTree.get<std::string>("<xmlattr>.pressedTexName");
+
+
+				fillerFuncArr.push_back(boost::bind(TUniversalButton::SquareButtonFiller, posFrom, posTo, normTexName, pressedTexName, _1));
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "TextButtonFiller")
+			{
+				TTextParams textParamsNormal;
+				TTextParams textParamsPressed;
+
+				boost::property_tree::ptree& textParamsNormalTree = fillerTree.find("TextParamsNormal")->second;
+
+				textParamsNormal.Serialize(textParamsNormalTree);
+
+				boost::property_tree::ptree& textParamsPressedTree = fillerTree.find("TextParamsPressed")->second;
+
+				textParamsPressed.Serialize(textParamsPressedTree);
+
+				fillerFuncArr.push_back(boost::bind(TUniversalButton::TextButtonFiller, posFrom, posTo, textParamsNormal, textParamsPressed, _1));
+
+			}
+		}
+
+	}
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(
+		TUniversalButton::CreateButtonWithFillers(posFrom, posTo, fillerFuncArr)
+		),
+		name,
+		group,
+		order);
+
+}
+
+
+
+
+void TEditWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	std::string widgetType = propertyTree.get<std::string>("<xmlattr>.type");
+	std::string name = propertyTree.get<std::string>("<xmlattr>.name");
+	std::string group = propertyTree.get<std::string>("<xmlattr>.group");
+
+	float xCenter = propertyTree.get<float>("<xmlattr>.xCenter");
+	float yCenter = propertyTree.get<float>("<xmlattr>.yCenter");
+	float width = propertyTree.get<float>("<xmlattr>.width");
+	float height = propertyTree.get<float>("<xmlattr>.height");
+	int order = propertyTree.get<int>("<xmlattr>.order", 0);
+
+	vec2 posFrom(xCenter - width*0.5f, yCenter - height*0.5f);
+	vec2 posTo(xCenter + width*0.5f, yCenter + height*0.5f);
+	/*
+	//The only one filler
+	std::string texName = propertyTree.get<std::string>("Filler.<xmlattr>.texName");
+
+	TTextParams textParams;
+
+	boost::property_tree::ptree& textParamsTree = propertyTree.find("Filler")->second.find("TextParams")->second;
+
+	textParams.Serialize(textParamsTree);
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(TEdit::CreateEdit(posFrom, posTo, texName, textParams)),
+		name,
+		group,
+		order);*/
+
+	std::vector<boost::function<void(TEdit*)>> fillerFuncArr;
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		if (v.first == "Filler")
+		{
+
+			boost::property_tree::ptree& fillerTree = v.second;
+
+			if (fillerTree.get<std::string>("<xmlattr>.type") == "EditFiller")
+			{
+
+				std::string texName = fillerTree.get<std::string>("<xmlattr>.texName");
+
+				TTextParams textParams;
+
+				boost::property_tree::ptree& textParamsTree = fillerTree.find("TextParams")->second;
+
+				textParams.Serialize(textParamsTree);
+
+				fillerFuncArr.push_back(boost::bind(TEdit::EditFiller, posFrom, posTo, texName, textParams, _1));
+
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "SmartValueTextFiller")
+			{
+				
+				std::string dictionaryName = fillerTree.get<std::string>("<xmlattr>.dictionaryName");
+				std::string smartValueName = fillerTree.get<std::string>("<xmlattr>.smartValueName");
+				fillerFuncArr.push_back(boost::bind(TEdit::SmartValueTextFiller, dictionaryName, smartValueName, _1));
+
+			}
+		}
+
+	}
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(
+		TEdit::CreateEditWithFillers(posFrom, posTo, fillerFuncArr)
+		),
+		name,
+		group,
+		order);
+}
+
+
+
+
+
+void TCheckBoxWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	std::string widgetType = propertyTree.get<std::string>("<xmlattr>.type");
+	std::string name = propertyTree.get<std::string>("<xmlattr>.name");
+	std::string group = propertyTree.get<std::string>("<xmlattr>.group");
+
+	float xCenter = propertyTree.get<float>("<xmlattr>.xCenter");
+	float yCenter = propertyTree.get<float>("<xmlattr>.yCenter");
+	float width = propertyTree.get<float>("<xmlattr>.width");
+	float height = propertyTree.get<float>("<xmlattr>.height");
+	int order = propertyTree.get<int>("<xmlattr>.order", 0);
+
+	vec2 posFrom(xCenter - width*0.5f, yCenter - height*0.5f);
+	vec2 posTo(xCenter + width*0.5f, yCenter + height*0.5f);
+
+	std::vector<boost::function<void(TCheckBox*)> > fillerFuncArr;
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		if (v.first == "Filler")
+		{
+
+			boost::property_tree::ptree& fillerTree = v.second;
+
+			if (fillerTree.get<std::string>("<xmlattr>.type") == "TextureFiller")
+			{
+				std::string texName = fillerTree.get<std::string>("<xmlattr>.texName");
+				std::string checkedTexName = fillerTree.get<std::string>("<xmlattr>.checkedTexName");
+
+				fillerFuncArr.push_back(boost::bind(TCheckBox::TextureFiller, posFrom, posTo, texName, checkedTexName, _1));
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "TextFiller")
+			{
+				TTextParams textParams;
+
+				boost::property_tree::ptree& textParamsTree = fillerTree.find("TextParams")->second;
+
+				textParams.Serialize(textParamsTree);
+
+				float textXCenter = fillerTree.get<float>("<xmlattr>.xCenter");
+				float textYCenter = fillerTree.get<float>("<xmlattr>.yCenter");
+				float textWidth = fillerTree.get<float>("<xmlattr>.width");
+				float textHeight = fillerTree.get<float>("<xmlattr>.height");
+
+				vec2 textPosFrom(textXCenter - textWidth*0.5f, textYCenter - textHeight*0.5f);
+				vec2 textPosTo(textXCenter + textWidth*0.5f, textYCenter + textHeight*0.5f);
+
+				fillerFuncArr.push_back(boost::bind(TCheckBox::TextFiller, textPosFrom, textPosTo, textParams, _1));
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "RadioButtonGroupFiller")
+			{
+				//std::string radioGroupName = fillerTree.get<std::string>("");
+				//fillerFuncArr.push_back(boost::bind(TCheckBox::RadioButtonGroupFiller, radioGroupName, _1));
+				throw ErrorToLog("RadioButtonGroupFiller is not allowed for checkboxes!");
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "SmartValueFiller")
+			{
+				std::string dictionaryName = fillerTree.get<std::string>("<xmlattr>.dictionaryName");
+				std::string smartValueName = fillerTree.get<std::string>("<xmlattr>.smartValueName");
+				fillerFuncArr.push_back(boost::bind(TCheckBox::SmartValueFiller, dictionaryName, smartValueName, _1));
+			}
+		}
+
+	}
+
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(
+		TCheckBox::CreateCheckBoxWithFillers(posFrom, posTo, fillerFuncArr)
+		),
+		name,
+		group,
+		order);
+
+}
+
+
+
+void TRadioButtonWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	std::string widgetType = propertyTree.get<std::string>("<xmlattr>.type");
+	std::string name = propertyTree.get<std::string>("<xmlattr>.name");
+	std::string group = propertyTree.get<std::string>("<xmlattr>.group");
+
+	float xCenter = propertyTree.get<float>("<xmlattr>.xCenter");
+	float yCenter = propertyTree.get<float>("<xmlattr>.yCenter");
+	float width = propertyTree.get<float>("<xmlattr>.width");
+	float height = propertyTree.get<float>("<xmlattr>.height");
+	int order = propertyTree.get<int>("<xmlattr>.order", 0);
+
+	vec2 posFrom(xCenter - width*0.5f, yCenter - height*0.5f);
+	vec2 posTo(xCenter + width*0.5f, yCenter + height*0.5f);
+
+	std::vector<boost::function<void(TRadioButton*)> > fillerFuncArr;
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		if (v.first == "Filler")
+		{
+
+			boost::property_tree::ptree& fillerTree = v.second;
+
+			if (fillerTree.get<std::string>("<xmlattr>.type") == "TextureFiller")
+			{
+				std::string texName = fillerTree.get<std::string>("<xmlattr>.texName");
+				std::string checkedTexName = fillerTree.get<std::string>("<xmlattr>.checkedTexName");
+
+				fillerFuncArr.push_back(boost::bind(TRadioButton::TextureFiller, posFrom, posTo, texName, checkedTexName, _1));
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "TextFiller")
+			{
+				TTextParams textParams;
+
+				boost::property_tree::ptree& textParamsTree = fillerTree.find("TextParams")->second;
+
+				textParams.Serialize(textParamsTree);
+
+				float textXCenter = fillerTree.get<float>("<xmlattr>.xCenter");
+				float textYCenter = fillerTree.get<float>("<xmlattr>.yCenter");
+				float textWidth = fillerTree.get<float>("<xmlattr>.width");
+				float textHeight = fillerTree.get<float>("<xmlattr>.height");
+
+				vec2 textPosFrom(textXCenter - textWidth*0.5f, textYCenter - textHeight*0.5f);
+				vec2 textPosTo(textXCenter + textWidth*0.5f, textYCenter + textHeight*0.5f);
+
+				fillerFuncArr.push_back(boost::bind(TRadioButton::TextFiller, textPosFrom, textPosTo, textParams, _1));
+
+			}
+			else if (fillerTree.get<std::string>("<xmlattr>.type") == "SmartValueFiller")
+			{
+				std::string dictionaryName = fillerTree.get<std::string>("<xmlattr>.dictionaryName");
+				std::string smartValueName = fillerTree.get<std::string>("<xmlattr>.smartValueName");
+
+				std::string smartValueType = fillerTree.get<std::string>("type");
+
+				if (smartValueType == "int")
+				{
+					int value = fillerTree.get<int>("value");
+					fillerFuncArr.push_back(boost::bind(TRadioButton::SmartValueFiller<int>, dictionaryName, smartValueName, value, _1));
+				}
+				else if (smartValueType == "float")
+				{
+					float value = fillerTree.get<float>("value");
+					fillerFuncArr.push_back(boost::bind(TRadioButton::SmartValueFiller<float>, dictionaryName, smartValueName, value, _1));
+				}
+				else if (smartValueType == "bool")
+				{
+					bool value = fillerTree.get<bool>("value");
+					fillerFuncArr.push_back(boost::bind(TRadioButton::SmartValueFiller<bool>, dictionaryName, smartValueName, value, _1));
+				}
+				else if (smartValueType == "string")
+				{
+					std::string value = fillerTree.get<std::string>("value");
+					fillerFuncArr.push_back(boost::bind(TRadioButton::SmartValueFiller<std::string>, dictionaryName, smartValueName, value, _1));
+				}
+				else
+				{
+					throw ErrorToLog("Unknown type: "+smartValueType);
+				}
+
+			}
+		}
+
+	}
+
+
+	ResourceManager->GUIManager.AddWidget(
+		std::shared_ptr<TInstancingWidgetAncestor>(
+		TRadioButton::CreateRadioButtonWithFillers(posFrom, posTo, fillerFuncArr)
+		),
+		name,
+		group,
+		order);
+}
+
+
+
+/*
+void TWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.begin()->second)
+	{
+		std::string widgetType = v.second.get<std::string>("<xmlattr>.type");
+
+
+		if (widgetType == "Button")
+		{
+			TButtonWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "Static")
+		{
+			TStaticWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "Edit")
+		{
+			TEditWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "CheckBox")
+		{
+			TCheckBoxWidgetParser().Serialize(v.second);
+		}
+	}
+}
+*/
+
+void TWidgetParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree)
+	{
+		std::string widgetType = v.second.get<std::string>("<xmlattr>.type");
+
+
+		if (widgetType == "Button")
+		{
+			TButtonWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "Static")
+		{
+			TStaticWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "DynamicText")
+		{
+			TDynamicTextWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "Edit")
+		{
+			TEditWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "CheckBox")
+		{
+			TCheckBoxWidgetParser().Serialize(v.second);
+		}
+		if (widgetType == "RadioButton")
+		{
+			TRadioButtonWidgetParser().Serialize(v.second);
+		}
+	}
+}
+
+
+void TWidgetListParser::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	TWidgetParser().Serialize(propertyTree.begin()->second);
+}
+
+
+} //namespace SE

src/GlobalConst.cpp

@@ -0,0 +1,7 @@
+#include "include/GlobalConst.h"
+
+namespace SE
+{
+
+
+} //namespace SE

src/HalibutAnimation/HalibutAnimation.cpp

@@ -0,0 +1,501 @@
+#include "include/Engine.h"
+
+#include "boost/assign.hpp"
+
+namespace SE
+{
+
+THalibutAnimObject::THalibutAnimObject(const std::string& texName, vec2 posFrom, vec2 posTo)
+	: TexName(texName)
+	, TotalAnimTime(0)
+	, CurrentAnimTime(0)
+	, CurrentAnimFrame(0)
+{
+	TRenderParams renderParams;
+
+	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = texName;
+	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;
+
+	TriangleListVector.push_back(std::pair<TRenderParams, TTriangleList>(renderParams, MakeTriangleList(posFrom, posTo)));
+
+	LeftBottomPos = posFrom;
+}
+
+
+void THalibutAnimObject::RefreshTriangleListVector()
+{
+	vec2 tex1 = AnimShotArr[CurrentAnimFrame].TexCoordFrom;
+	vec2 tex2 = vec2(AnimShotArr[CurrentAnimFrame].TexCoordFrom.v[0], AnimShotArr[CurrentAnimFrame].TexCoordTo.v[1]);
+	vec2 tex3 = AnimShotArr[CurrentAnimFrame].TexCoordTo;
+	vec2 tex4 = vec2(AnimShotArr[CurrentAnimFrame].TexCoordTo.v[0], AnimShotArr[CurrentAnimFrame].TexCoordFrom.v[1]);
+
+	TTriangleList& triangleList = TriangleListVector.begin()->second;
+
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][0] = tex1;
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][1] = tex2;
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][2] = tex3;
+
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][3] = tex3;
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][4] = tex4;
+	triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][5] = tex1;
+
+	triangleList.RefreshBuffer();
+}
+
+void THalibutAnimObject::AddAnimShot(vec2 texCoordFrom, vec2 texCoordTo, cardinal timePassedFromStart)
+{
+	AnimShotArr.push_back(TAnimShot(texCoordFrom, texCoordTo, timePassedFromStart));
+
+	CalcTotalAnimTime(); //Not rational but prevents a lot of stupid mistakes :(
+}
+
+void THalibutAnimObject::CalcTotalAnimTime()
+{
+	if (AnimShotArr.size() == 0)
+	{
+		TotalAnimTime = 0;
+	}
+	else
+	{
+		std::vector<TAnimShot>::iterator i = AnimShotArr.end();
+		
+		i--;
+
+		TotalAnimTime = i->TimePassedFromStart;
+	}
+
+}
+
+void THalibutAnimObject::Update(cardinal dt)
+{
+	if (AnimShotArr.size() == 0)
+	{
+		return;
+	}
+
+	//cardinal prevCurrentAnimTime = CurrentAnimTime;
+
+	CurrentAnimTime += dt;
+
+	cardinal prevCurrentAnimFrame = CurrentAnimFrame;
+
+	while (CurrentAnimTime > AnimShotArr[CurrentAnimFrame].TimePassedFromStart)
+	{
+		CurrentAnimFrame++;
+
+		if (CurrentAnimFrame == AnimShotArr.size())
+		{
+			CurrentAnimFrame = 0;
+			CurrentAnimTime -= TotalAnimTime;
+		}
+	}
+
+	if (prevCurrentAnimFrame != CurrentAnimFrame)
+	{
+		RefreshTriangleListVector();
+	}
+}
+
+void THalibutAnimObject::Reset()
+{
+	CurrentAnimFrame = 0;
+	CurrentAnimTime = 0;
+	RefreshTriangleListVector();
+}
+
+
+void THalibutAnimObject::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	Clear();
+
+	TexName = propertyTree.get<std::string>("Animation.TexName");
+
+	vec2 posFrom, posTo;
+
+	posFrom.v[0] = propertyTree.get<float>("Animation.PosFrom.<xmlattr>.x");
+	posFrom.v[1] = propertyTree.get<float>("Animation.PosFrom.<xmlattr>.y");
+	posTo.v[0] = propertyTree.get<float>("Animation.PosTo.<xmlattr>.x");
+	posTo.v[1] = propertyTree.get<float>("Animation.PosTo.<xmlattr>.y");
+
+	TRenderParams renderParams;
+
+	renderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM] = TexName;
+	renderParams.FloatMap[CONST_STRING_TRANSPARENCY_UNIFORM] = 1.f;
+
+
+	TriangleListVector.push_back(std::pair<TRenderParams, TTriangleList>(renderParams, MakeTriangleList(posFrom, posTo)));
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Animation.Frames"))
+	{
+		vec2 texCoordFrom, texCoordTo;
+			
+		texCoordFrom.v[0] = v.second.get<float>("TexCoordFrom.<xmlattr>.x");
+		texCoordFrom.v[1] = v.second.get<float>("TexCoordFrom.<xmlattr>.y");
+		texCoordTo.v[0] = v.second.get<float>("TexCoordTo.<xmlattr>.x");
+		texCoordTo.v[1] = v.second.get<float>("TexCoordTo.<xmlattr>.y");
+
+		cardinal timePassedFromStart = v.second.get<cardinal>("TimePassed");
+
+		AddAnimShot(texCoordFrom, texCoordTo, timePassedFromStart);
+		
+	}
+
+}
+
+
+void THalibutAnimObject::Clear()
+{
+	AnimShotArr.clear();
+
+	TriangleListVector.clear();
+
+	TotalAnimTime = 0;
+	CurrentAnimTime = 0;
+	CurrentAnimFrame = 0;
+}
+
+
+
+//==================================================
+
+
+
+THalibutExternalAnimObject::THalibutExternalAnimObject(TRenderPairList::iterator renderPairIter, cardinal rectFrom, cardinal rectCount)
+	: RectCount(rectCount)
+	, RectFrom(rectFrom)
+	, TotalAnimTime(0)
+	, CurrentAnimTime(0)
+	, CurrentAnimFrame(0)
+	, RenderPairIter(renderPairIter)
+{
+}
+
+THalibutExternalAnimObject::THalibutExternalAnimObject(const THalibutExternalAnimObject& copyFrom)
+	: CurrentAnimTime(copyFrom.CurrentAnimTime)
+	, TotalAnimTime(copyFrom.TotalAnimTime)
+	, CurrentAnimFrame(copyFrom.CurrentAnimFrame)
+	, AnimShotArr(copyFrom.AnimShotArr)
+	, RenderPairIter(copyFrom.RenderPairIter)
+	, RectCount(copyFrom.RectCount)
+	, RectFrom(copyFrom.RectFrom)
+{
+	
+}
+
+THalibutExternalAnimObject& THalibutExternalAnimObject::operator=(const THalibutExternalAnimObject& copyFrom)
+{
+	//Self-assignment is ok
+	
+	CurrentAnimTime = copyFrom.CurrentAnimTime;
+	TotalAnimTime = copyFrom.TotalAnimTime;
+
+	CurrentAnimFrame = copyFrom.CurrentAnimFrame;
+	
+	AnimShotArr = copyFrom.AnimShotArr;
+
+	RenderPairIter = copyFrom.RenderPairIter;
+
+	RectCount = copyFrom.RectCount;
+	RectFrom = copyFrom.RectFrom;
+	
+	return *this;
+
+}
+
+THalibutExternalAnimObject::~THalibutExternalAnimObject()
+{
+	
+}
+
+void THalibutExternalAnimObject::ReplaceAnimObject(TRenderPairList::iterator renderPairIter, cardinal rectFrom)
+{
+	
+	RectFrom = rectFrom;
+	RenderPairIter = renderPairIter;
+}
+
+void THalibutExternalAnimObject::RefreshTriangleListVector()
+{
+
+	vec2 tex1 = AnimShotArr[CurrentAnimFrame].TexCoordFrom;
+	vec2 tex2 = vec2(AnimShotArr[CurrentAnimFrame].TexCoordFrom.v[0], AnimShotArr[CurrentAnimFrame].TexCoordTo.v[1]);
+	vec2 tex3 = AnimShotArr[CurrentAnimFrame].TexCoordTo;
+	vec2 tex4 = vec2(AnimShotArr[CurrentAnimFrame].TexCoordTo.v[0], AnimShotArr[CurrentAnimFrame].TexCoordFrom.v[1]);
+
+
+
+	for (cardinal i = RectFrom; i<RectFrom+RectCount; i++)
+	{
+		RenderPairIter->second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][i*6+0] = tex1;
+		RenderPairIter->second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][i*6+1] = tex2;
+		RenderPairIter->second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][i*6+2] = tex3;
+
+		RenderPairIter->second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][i*6+3] = tex3;
+		RenderPairIter->second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][i*6+4] = tex4;
+		RenderPairIter->second.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][i*6+5] = tex1;
+	}
+
+	RenderPairIter->second.NeedRefreshBuffer = true;
+
+}
+
+void THalibutExternalAnimObject::AddAnimShot(vec2 texCoordFrom, vec2 texCoordTo, cardinal timePassedFromStart)
+{
+
+	AnimShotArr.push_back(TAnimShot(texCoordFrom, texCoordTo, timePassedFromStart));
+
+	CalcTotalAnimTime(); //Not rational but prevents a lot of stupid mistakes :(
+}
+
+void THalibutExternalAnimObject::CalcTotalAnimTime()
+{
+
+	if (AnimShotArr.size() == 0)
+	{
+		TotalAnimTime = 0;
+	}
+	else
+	{
+		std::vector<TAnimShot>::iterator i = AnimShotArr.end();
+		
+		i--;
+
+		TotalAnimTime = i->TimePassedFromStart;
+	}
+
+}
+
+void THalibutExternalAnimObject::Update(cardinal dt)
+{
+
+	if (AnimShotArr.size() == 0)
+	{
+		return;
+	}
+
+	//cardinal prevCurrentAnimTime = CurrentAnimTime;
+
+	CurrentAnimTime += dt;
+
+	cardinal prevCurrentAnimFrame = CurrentAnimFrame;
+
+	while (CurrentAnimTime > AnimShotArr[CurrentAnimFrame].TimePassedFromStart)
+	{
+		CurrentAnimFrame++;
+
+		if (CurrentAnimFrame == AnimShotArr.size())
+		{
+			CurrentAnimFrame = 0;
+			CurrentAnimTime -= TotalAnimTime;
+		}
+	}
+
+	if (prevCurrentAnimFrame != CurrentAnimFrame)
+	{
+		RefreshTriangleListVector();
+	}
+}
+
+void THalibutExternalAnimObject::Reset()
+{
+	
+	CurrentAnimFrame = 0;
+	CurrentAnimTime = 0;
+	RefreshTriangleListVector();
+}
+
+
+void THalibutExternalAnimObject::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	
+	//*Console<<"Halibut external anim object serialize\n";
+	Clear();
+
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Animation.Frames"))
+	{
+		vec2 texCoordFrom, texCoordTo;
+			
+		texCoordFrom.v[0] = v.second.get<float>("TexCoordFrom.<xmlattr>.x");
+		texCoordFrom.v[1] = v.second.get<float>("TexCoordFrom.<xmlattr>.y");
+		texCoordTo.v[0] = v.second.get<float>("TexCoordTo.<xmlattr>.x");
+		texCoordTo.v[1] = v.second.get<float>("TexCoordTo.<xmlattr>.y");
+
+		cardinal timePassedFromStart = v.second.get<cardinal>("TimePassed");
+
+		AddAnimShot(texCoordFrom, texCoordTo, timePassedFromStart);
+		
+	}
+
+}
+
+
+void THalibutExternalAnimObject::Clear()
+{
+	
+	//*Console<<"Halibut external anim object clear\n";
+
+	AnimShotArr.clear();
+
+	TotalAnimTime = 0;
+	CurrentAnimTime = 0;
+	CurrentAnimFrame = 0;
+}
+
+
+//==================================================
+
+
+THalibutAnimationManager::~THalibutAnimationManager()
+{
+	*Console<<"HalibutAnimationManager deleting...";
+}
+
+std::vector<THalibutAnimObjectRecord>::iterator THalibutAnimationManager::FindAnimObjectByName(const std::string& name)
+{
+	std::vector<THalibutAnimObjectRecord>::iterator i;
+
+	for (i = HalibutAnimObjectArr.begin(); i != HalibutAnimObjectArr.end(); ++i)
+	{
+		if (i->Name == name)
+		{
+			return i;
+		}
+	}
+
+	//throw ErrorToLog("ERROR: Animation not found: " + name + "\n");
+
+	return HalibutAnimObjectArr.end();
+}
+
+
+void THalibutAnimationManager::ReplaceAnimationObject(const std::string& animName, TRenderPairList::iterator renderPairIter, cardinal rectFrom)
+{
+	
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+
+	if (i == HalibutAnimObjectArr.end())
+	{
+		throw ErrorToLog("ERROR: Animation not found: " + animName);
+	}
+
+	i->HalibutAnimObject.ReplaceAnimObject(renderPairIter, rectFrom);
+}
+
+void THalibutAnimationManager::AddAnimationObject(const std::string& animName, THalibutExternalAnimObject halibutExternalAnimObject)
+{
+	
+	if (FindAnimObjectByName(animName) == HalibutAnimObjectArr.end())
+	{
+		HalibutAnimObjectArr.push_back(THalibutAnimObjectRecord(animName, halibutExternalAnimObject, THalibutAnimObjectRecord::AS_STOP));
+	}
+}
+
+
+void THalibutAnimationManager::DeleteAnimationObject(const std::string& animName)
+{
+	
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+	if (i != HalibutAnimObjectArr.end())
+	{
+		HalibutAnimObjectArr.erase(i);
+	}
+
+}
+
+
+bool THalibutAnimationManager::AnimationExists(const std::string& animName)
+{
+	return FindAnimObjectByName(animName) != HalibutAnimObjectArr.end();
+}
+
+void THalibutAnimationManager::Update(cardinal dt)
+{
+	
+	std::vector<THalibutAnimObjectRecord>::iterator i;
+
+	for (i = HalibutAnimObjectArr.begin(); i != HalibutAnimObjectArr.end(); ++i)
+	{
+		if (i->AnimState == THalibutAnimObjectRecord::AS_PLAY)
+		{
+			i->HalibutAnimObject.Update(dt);
+		}
+	}
+}
+
+
+
+void THalibutAnimationManager::StartAnimation(const std::string& animName)
+{
+	
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+
+	if (FindAnimObjectByName(animName) == HalibutAnimObjectArr.end())
+	{
+		return;
+	}
+
+	i->AnimState = THalibutAnimObjectRecord::AS_PLAY;
+}
+
+void THalibutAnimationManager::StopAnimation(const std::string& animName)
+{
+	
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+
+	if (FindAnimObjectByName(animName) == HalibutAnimObjectArr.end())
+	{
+		return;
+	}
+
+	i->AnimState = THalibutAnimObjectRecord::AS_STOP;
+
+	i->HalibutAnimObject.Reset();
+}
+
+void THalibutAnimationManager::PauseAnimation(const std::string& animName)
+{
+	
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+
+	i->AnimState = THalibutAnimObjectRecord::AS_STOP;
+}
+
+/*
+void THalibutAnimationManager::HideAnimation(const std::string& animName)
+{
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+
+	i->Visible = false;
+}
+
+
+void THalibutAnimationManager::ShowAnimation(const std::string& animName)
+{
+	std::vector<THalibutAnimObjectRecord>::iterator i = FindAnimObjectByName(animName);
+
+	i->Visible = true;
+}*/
+
+void THalibutAnimationManager::PrintAnimationList()
+{
+
+	static std::map<THalibutAnimObjectRecord::TAnimState, std::string> mapAnimState = boost::assign::map_list_of(THalibutAnimObjectRecord::AS_PLAY, "AS_PLAY")(THalibutAnimObjectRecord::AS_STOP, "AS_STOP");
+
+	std::vector<THalibutAnimObjectRecord>::iterator i;
+
+	Console->PrintImmediate("==========> ANIMATION LIST <==========");
+
+	for (i = HalibutAnimObjectArr.begin(); i != HalibutAnimObjectArr.end(); ++i)
+	{
+		Console->PrintImmediate(i->Name + " " + mapAnimState[i->AnimState]);
+	}
+}
+
+
+void THalibutAnimationManager::BindFunctions()
+{
+	//*Console<<"Bind functions in THalibutAnimationManager\n";
+	ResourceManager->ScriptManager.AddFunction("pal", TScriptInfo("PrintAnimationList"), *this, &THalibutAnimationManager::PrintAnimationList);
+}
+
+} //namespace SE

src/HalibutEngineAndroid.cpp

@@ -0,0 +1,175 @@
+#include "include/HalibutEngineAndroid.h"
+
+
+namespace SE
+{
+
+TJavaConsole* Console = NULL;
+
+THalibutResourceManager* ResourceManager = NULL;
+
+THalibutRendererAndroid* Renderer = NULL;
+
+
+TApplication::TApplication()
+{
+}
+
+void TApplication::OuterInit(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+
+    OuterDeinit();
+    
+    Console = new TJavaConsole;
+	
+	*Console<<std::string("Console successfully started!!!");
+	
+    ResourceManager = new THalibutResourceManager;
+
+	Renderer = new THalibutRendererAndroid;
+	
+	ResourceManager->ScriptManager.BindBasicFunctions();
+	
+	InnerInit();
+	
+	Renderer->InitOpenGL(screenWidth, screenHeight, matrixWidth, matrixHeight);
+	
+	
+}
+
+void TApplication::OuterDeinit()
+{
+	if (Console != NULL)
+	{
+	*Console<<"OuterDeinit";
+    }
+	InnerDeinit();
+    
+	
+	if (ResourceManager != NULL)
+    {
+	   delete ResourceManager;
+	   ResourceManager = NULL;
+    }
+	
+    if (Renderer != NULL)
+    {
+	   delete Renderer;
+	   Renderer = NULL;
+    }
+    
+    
+    
+    if (Console != NULL)
+    {
+	   delete Console;
+	   Console = NULL;
+    }
+	
+}
+
+TApplication::~TApplication()
+{
+    OuterDeinit();
+}
+
+
+void TApplication::OnKeyPress(cardinal key)
+{
+	//For Android 
+	//7-16 => "0".."9"
+	//29-54 => "a".."z"
+	//
+
+	if (IsConsoleOut)
+	{
+		
+		if (key == 96 || key == 126) //` or ~
+		{
+	
+			IsConsoleOut = false;
+		}
+		else if (key == 8) //Backspace
+		{
+			if (Console->ConsoleInput.size() > 0 && Console->ConsoleCursor > 0)
+			{
+				//Console->ConsoleInput.erase(Console->ConsoleInput.end()-1);
+				Console->ConsoleInput.erase(Console->ConsoleInput.begin() + Console->ConsoleCursor-1);
+				Console->ConsoleCursor--;
+			}
+		}
+		else if (key == 13 || key == 10) //Enter
+		{
+			ResourceManager->ScriptManager.RunScript(Console->ConsoleInput);
+			*Console<<"===>"+Console->ConsoleInput+"<===";
+
+			Console->InputHistory.push_back(Console->ConsoleInput);
+
+			Console->InputHistoryCursor = Console->InputHistory.size();
+
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = 0;
+		}
+		else if (key >= 32 && key <= 255) //ASCII
+		{
+			//Console->ConsoleInput += static_cast<char>(key);
+			Console->ConsoleInput.insert(Console->ConsoleInput.begin()+Console->ConsoleCursor, static_cast<char>(key));
+			Console->ConsoleCursor++;
+		}
+		else if (key > 0x100) //VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT
+		{
+		/*
+			cardinal realKey = key - 0x100;
+
+			if (realKey == VK_UP)
+			{
+				if (Console->InputHistoryCursor > 0)
+				{
+					Console->InputHistoryCursor--;
+					Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+					Console->ConsoleCursor = Console->ConsoleInput.size();
+				}
+			}
+			if (realKey == VK_DOWN)
+			{
+				if ( Console->InputHistoryCursor+1 < Console->InputHistory.size())
+				{
+					Console->InputHistoryCursor++;
+					Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+					Console->ConsoleCursor = Console->ConsoleInput.size();
+				}
+			}
+			if (realKey == VK_LEFT)
+			{
+				if (Console->ConsoleCursor > 0)
+				{
+					Console->ConsoleCursor--;
+				}
+			}
+			if (realKey == VK_RIGHT)
+			{
+				if (Console->ConsoleCursor < Console->ConsoleInput.size())
+				{
+					Console->ConsoleCursor++;
+				}
+			}*/
+		}
+		else
+		{
+			*Console<<std::string("Key is ")+tostr(key);
+		}
+
+	}
+	else
+	{
+		if (key == 96 || key == 126) //~
+		{
+			IsConsoleOut = true;
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = Console->ConsoleInput.size();
+		}
+	}
+}
+
+
+} //namespace SE

src/HalibutEngineInterface.cpp

@@ -0,0 +1,76 @@
+#include "include/HalibutEngineInterface.h"
+#include "include/Engine.h"
+
+
+namespace SE
+{
+
+TApplicationAncestor::TApplicationAncestor() 
+{
+}
+
+
+void TApplicationAncestor::OuterDraw() 
+{   
+
+    CheckGlError("THalibutApplicationInterface::OuterDraw 1");
+	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+	glActiveTexture(GL_TEXTURE0);
+	RenderUniform1i("Texture", 0);
+	RenderUniform1f("Transparency", 1.f);
+
+	InnerDraw();
+
+	CheckGlError("THalibutApplicationInterface::OuterDraw 1.5");
+
+	ResourceManager->GUIManager.Draw();
+
+	if (IsConsoleOut) 
+	{
+		Console->Draw();
+	}
+    CheckGlError("THalibutApplicationInterface::OuterDraw 2");
+
+}
+
+
+
+void TApplicationAncestor::OuterUpdate(cardinal dt)
+{
+    CheckGlError();
+	ResourceManager->GUIManager.Update(dt);
+	ResourceManager->HalibutAnimationManager.Update(dt);
+
+    
+#ifndef TARGET_IOS
+	ResourceManager->SoundManager.Update(dt);
+#endif
+    CheckGlError();
+	InnerUpdate(dt);
+
+	CheckGlError();
+}
+
+
+void TApplicationAncestor::OuterOnTapDown(vec2 p)
+{
+	ResourceManager->GUIManager.OnMouseDown(p);
+	InnerOnTapDown(p);
+}
+
+void TApplicationAncestor::OuterOnTapUp(vec2 p)
+{
+	ResourceManager->GUIManager.OnMouseUp(p);
+	InnerOnTapUp(p);
+}
+
+void TApplicationAncestor::OuterOnMove(vec2 shift)
+{
+	ResourceManager->GUIManager.OnMove(shift);
+	InnerOnMove(shift);
+}
+
+
+} //namespace SE

src/HalibutEngineIos.cpp

@@ -0,0 +1,187 @@
+//
+//  HalibutEngineIos.cpp
+//  Halibut Engine
+//
+//  Created by vvv ооо on 13.07.12.
+//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
+//
+
+#include <iostream>
+
+#include "include/Engine.h"
+
+#include "include/HalibutEngineIos.h"
+
+namespace SE
+{
+
+TIosConsole* Console = NULL;
+
+THalibutResourceManager* ResourceManager = NULL;
+
+THalibutRenderIos* Renderer = NULL;
+
+
+TApplication::TApplication()
+{
+}
+
+void TApplication::OuterInit(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+    
+    OuterDeinit();
+    
+    Console = new TIosConsole;
+	
+	*Console<<std::string("Console successfully started!!!");
+	
+    ResourceManager = new THalibutResourceManager;
+    
+	Renderer = new THalibutRenderIos;
+	
+	ResourceManager->ScriptManager.BindBasicFunctions();
+	
+	InnerInit();
+    
+	Renderer->InitOpenGL(screenWidth, screenHeight, matrixWidth, matrixHeight);
+	
+	
+}
+
+void TApplication::OuterDeinit()
+{
+	if (Console != NULL)
+	{
+        *Console<<"OuterDeinit";
+    }
+	InnerDeinit();
+    
+	
+	if (ResourceManager != NULL)
+    {
+        delete ResourceManager;
+        ResourceManager = NULL;
+    }
+	
+    if (Renderer != NULL)
+    {
+        delete Renderer;
+        Renderer = NULL;
+    }
+    
+    
+    
+    if (Console != NULL)
+    {
+        delete Console;
+        Console = NULL;
+    }
+	
+}
+
+TApplication::~TApplication()
+{
+    OuterDeinit();
+}
+
+
+void TApplication::OnKeyPress(cardinal key)
+{
+	//For Android 
+	//7-16 => "0".."9"
+	//29-54 => "a".."z"
+	//
+    
+	if (IsConsoleOut)
+	{
+		
+		if (key == 96 || key == 126) //` or ~
+		{
+            
+			IsConsoleOut = false;
+		}
+		else if (key == 8) //Backspace
+		{
+			if (Console->ConsoleInput.size() > 0 && Console->ConsoleCursor > 0)
+			{
+				//Console->ConsoleInput.erase(Console->ConsoleInput.end()-1);
+				Console->ConsoleInput.erase(Console->ConsoleInput.begin() + Console->ConsoleCursor-1);
+				Console->ConsoleCursor--;
+			}
+		}
+		else if (key == 13 || key == 10) //Enter
+		{
+			ResourceManager->ScriptManager.RunScript(Console->ConsoleInput);
+			*Console<<"===>"+Console->ConsoleInput+"<===";
+            
+			Console->InputHistory.push_back(Console->ConsoleInput);
+            
+			Console->InputHistoryCursor = Console->InputHistory.size();
+            
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = 0;
+		}
+		else if (key >= 32 && key <= 255) //ASCII
+		{
+			//Console->ConsoleInput += static_cast<char>(key);
+			Console->ConsoleInput.insert(Console->ConsoleInput.begin()+Console->ConsoleCursor, static_cast<char>(key));
+			Console->ConsoleCursor++;
+		}
+		else if (key > 0x100) //VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT
+		{
+            /*
+             cardinal realKey = key - 0x100;
+             
+             if (realKey == VK_UP)
+             {
+             if (Console->InputHistoryCursor > 0)
+             {
+             Console->InputHistoryCursor--;
+             Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+             Console->ConsoleCursor = Console->ConsoleInput.size();
+             }
+             }
+             if (realKey == VK_DOWN)
+             {
+             if ( Console->InputHistoryCursor+1 < Console->InputHistory.size())
+             {
+             Console->InputHistoryCursor++;
+             Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+             Console->ConsoleCursor = Console->ConsoleInput.size();
+             }
+             }
+             if (realKey == VK_LEFT)
+             {
+             if (Console->ConsoleCursor > 0)
+             {
+             Console->ConsoleCursor--;
+             }
+             }
+             if (realKey == VK_RIGHT)
+             {
+             if (Console->ConsoleCursor < Console->ConsoleInput.size())
+             {
+             Console->ConsoleCursor++;
+             }
+             }*/
+		}
+		else
+		{
+			*Console<<std::string("Key is ")+tostr(key);
+		}
+        
+	}
+	else
+	{
+		if (key == 96 || key == 126) //~
+		{
+			IsConsoleOut = true;
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = Console->ConsoleInput.size();
+		}
+	}
+}
+
+
+
+} //namespace SE

src/HalibutEngineWindows.cpp

@@ -0,0 +1,510 @@
+#include "include/Utils/Utils.h"
+#include "include/HalibutEngineWindows.h"
+
+namespace SE
+{
+
+//==============================================================
+//========= GLOBAL VARIABLES - REMEMBER THIS LIST!!! ===========
+//==============================================================
+
+HGLRC hRC;		//Render context
+HWND Hwnd;		//Main window handle
+HDC hDC;		//Device context
+
+TFileConsole* Console = NULL;
+
+THalibutRenderer* Renderer = NULL;
+
+THalibutResourceManager* ResourceManager = NULL;
+
+
+//==============================================================
+//=============== GLOBAL VARS ENDS =============================
+//==============================================================
+
+const int CONST_DEFAULT_SCREEN_WIDTH = 800;
+const int CONST_DEFAULT_SCREEN_HEIGHT = 600;
+
+const cardinal CONST_TIMER_INTERVAL = 10;
+
+//There might be anything
+const char CONST_WINDOW_CLASS_NAME[] = "TSalmonEngineForm";
+
+//To calculate when to call Update
+cardinal NewTickCount;
+cardinal LastTickCount;
+
+vec2 MouseButtonPos;
+vec2 MouseTotalShift;
+bool MouseButtonPressed = false;
+bool MouseMoved = false;
+
+//User application
+TApplication* App = NULL;
+
+
+TApplication::TApplication() 
+	: X(0)
+	, Y(0)
+	, Width(800)
+	, Height(600)
+	, MatrixWidth(0.f)
+	, MatrixHeight(0.f)
+	, WindowName("Halibut Engine")
+	, LogFilename("log.txt")
+{
+	for(int i=0; i<256; i++)
+	{
+		KeyboardBuffer[i] = 0;
+	}
+}
+
+TApplication::~TApplication()
+{
+}
+
+const std::string& TApplication::GetLogFilename()
+{
+	return LogFilename;
+} 
+
+char TApplication::GetKeyState(cardinal keyNum)
+{
+	if (keyNum > 255)
+		throw ErrorToLog("GetKeyState - invalid key number!");
+
+	return KeyboardBuffer[keyNum];
+}
+
+
+void TApplication::SetKeyboardBuffer(const unsigned char* source)
+{
+	memcpy((unsigned char*)KeyboardBuffer, source, 256);
+}
+
+void TApplication::OnKeyPress(cardinal key)
+{
+
+	if (IsConsoleOut)
+	{
+		
+		if (key == 96 || key == 126) //~
+		{
+			IsConsoleOut = false;
+		}
+		else if (key == 8) //Backspace
+		{
+			if (Console->ConsoleInput.size() > 0 && Console->ConsoleCursor > 0)
+			{
+				Console->ConsoleInput.erase(Console->ConsoleInput.begin() + Console->ConsoleCursor-1);
+				Console->ConsoleCursor--;
+			}
+		}
+		else if (key == 13|| key == 10) //Enter
+		{
+			ResourceManager->ScriptManager.RunScript(Console->ConsoleInput);
+
+			Console->InputHistory.push_back(Console->ConsoleInput);
+
+			Console->InputHistoryCursor = Console->InputHistory.size();
+
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = 0;
+		}
+		else if (key >= 32 && key <= 255) //ASCII
+		{
+			Console->ConsoleInput.insert(Console->ConsoleInput.begin()+Console->ConsoleCursor, static_cast<char>(key));
+			Console->ConsoleCursor++;
+		}
+		else if (key > 0x100) //VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT
+		{
+			cardinal realKey = key - 0x100;
+
+			if (realKey == VK_UP)
+			{
+				if (Console->InputHistoryCursor > 0)
+				{
+					Console->InputHistoryCursor--;
+					Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+					Console->ConsoleCursor = Console->ConsoleInput.size();
+				}
+			}
+			if (realKey == VK_DOWN)
+			{
+				if ( Console->InputHistoryCursor+1 < Console->InputHistory.size())
+				{
+					Console->InputHistoryCursor++;
+					Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+					Console->ConsoleCursor = Console->ConsoleInput.size();
+				}
+			}
+			if (realKey == VK_LEFT)
+			{
+				if (Console->ConsoleCursor > 0)
+				{
+					Console->ConsoleCursor--;
+				}
+			}
+			if (realKey == VK_RIGHT)
+			{
+				if (Console->ConsoleCursor < Console->ConsoleInput.size())
+				{
+					Console->ConsoleCursor++;
+				}
+			}
+
+		}
+		else
+		{
+			*Console<<"Key is "+tostr(key)+endl;
+		}
+
+	}
+	else
+	{
+		ResourceManager->GUIManager.KeyPressedSignal(key);
+
+		if (key == 96 || key == 126) //~
+		{
+			IsConsoleOut = true;
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = Console->ConsoleInput.size();
+		}
+	}
+}
+
+
+void DrawScene()
+{
+	App->OuterDraw();
+	SwapBuffers(hDC);
+}
+
+void ProcessTickCount()
+{
+	//unsigned char keyboardStateArr[256];
+
+	NewTickCount = GetTickCount();
+	if (NewTickCount - LastTickCount > CONST_TIMER_INTERVAL)
+	{
+		/*
+		GetKeyboardState((unsigned char*)keyboardStateArr);
+		App->SetKeyboardBuffer((unsigned char*)keyboardStateArr);
+		*/
+	
+		App->OuterUpdate(NewTickCount - LastTickCount);
+		LastTickCount = NewTickCount;
+	}
+
+}
+
+LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{ 
+    static PAINTSTRUCT ps;
+
+	TMouseState mouseState;
+
+    switch(uMsg) 
+	{
+	case WM_CLOSE:
+		Hwnd = 0; //HACK to force window to close
+		PostQuitMessage(0);
+		//Xperimental
+		return DefWindowProc(hWnd, uMsg, wParam, lParam); 
+
+		break;
+	case WM_PAINT: 
+		DrawScene();
+		
+		BeginPaint(hWnd, &ps);
+		EndPaint(hWnd, &ps);
+
+		ProcessTickCount();
+		break;
+	case WM_SIZE:
+		
+		PostMessage(hWnd, WM_PAINT, 0, 0);
+		break;
+	case WM_CHAR:
+		App->OnKeyPress(wParam);
+		/*
+		switch (wParam) 
+		{
+		case 27:
+				PostQuitMessage(0);
+				Hwnd = 0;
+				
+				//Xperimental
+				return DefWindowProc(hWnd, uMsg, wParam, lParam); 
+
+				break;
+		//... Will add more code later
+		}
+		*/
+		break;
+	case WM_KEYDOWN:
+		//Special for arrow keys
+
+		if (wParam == VK_UP || wParam == VK_DOWN || wParam == VK_LEFT || wParam == VK_RIGHT)
+		{
+			App->OnKeyPress(0x100 + wParam);
+		}
+
+		break;
+	case WM_MOUSEMOVE:
+		mouseState.X = (lParam << 16) >> 16;
+		mouseState.Y = lParam >> 16;
+		mouseState.LeftButtonPressed = (wParam & MK_LBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_MBUTTON);
+		mouseState.RightButtonPressed = (wParam & MK_RBUTTON);
+
+		App->OnMouseMove(mouseState);
+
+		if (MouseButtonPressed)
+		{
+			vec2 currentMousePos(static_cast<float>(mouseState.X), static_cast<float>(App->Height - mouseState.Y));
+			vec2 shift = (MouseButtonPos - currentMousePos);
+			//shift.v[1] = - shift.v[1];
+			App->OuterOnMove(shift);
+			//App->OuterOnMove(currentMousePos - MouseButtonPos);
+			MouseButtonPos = currentMousePos;
+
+			MouseTotalShift += shift;
+
+			if (fabs(MouseTotalShift.v[0]) > 10.f || fabs(MouseTotalShift.v[1]) > 10.f)
+			{
+				MouseMoved = true;
+			}
+		}
+
+		break;
+
+	case WM_LBUTTONDOWN:
+	case WM_RBUTTONDOWN:
+		mouseState.X = (lParam << 16) >> 16;
+		mouseState.Y = lParam >> 16;
+		mouseState.LeftButtonPressed = (wParam & MK_LBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_MBUTTON);
+		mouseState.RightButtonPressed = (wParam & MK_RBUTTON);
+
+		MouseButtonPos = vec2(static_cast<float>(mouseState.X), static_cast<float>(App->Height - mouseState.Y));
+
+		if (mouseState.LeftButtonPressed)
+		{
+			App->OuterOnTapDown(MouseButtonPos);
+
+		}
+
+		MouseButtonPressed = true;
+
+		MouseMoved = false;
+
+		MouseTotalShift = vec2(0,0);
+		
+
+
+		break;
+	case WM_LBUTTONUP:
+	case WM_RBUTTONUP:
+		mouseState.X = (lParam << 16) >> 16;
+		mouseState.Y = lParam >> 16;
+		mouseState.LeftButtonPressed = (wParam & MK_LBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_MBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_RBUTTON);
+
+		if (!MouseMoved)
+		{
+			App->OuterOnTapUp(vec2(static_cast<float>(mouseState.X), static_cast<float>(App->Height - mouseState.Y)));
+		}
+
+		MouseButtonPressed = false;
+
+		break;
+	
+	case WM_MOUSEWHEEL:
+		App->OnMouseWheel(wParam >> 16);
+		break;
+    }
+
+    return DefWindowProc(hWnd, uMsg, wParam, lParam); 
+} 
+
+bool CreateOpenGLWindow(const char* title, int x, int y, int width, int height,HWND& hWnd, HDC& hDC, HGLRC& hRC)
+{
+    int pf;
+    WNDCLASS wc;
+    PIXELFORMATDESCRIPTOR pfd;
+    static HINSTANCE hInstance = 0;
+
+    if (!hInstance) 
+	{
+		hInstance = GetModuleHandle(NULL);
+		wc.style = CS_OWNDC;
+		wc.lpfnWndProc = (WNDPROC)WindowProc;
+		wc.cbClsExtra = 0;
+		wc.cbWndExtra = 0;
+		wc.hInstance = hInstance;
+		wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
+		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+		wc.hbrBackground = NULL;
+		wc.lpszMenuName  = NULL;
+		wc.lpszClassName = CONST_WINDOW_CLASS_NAME;
+
+		if (!RegisterClass(&wc)) 
+		{
+			return NULL;
+		}
+    }
+
+	RECT r;
+	r.left = x;
+	r.right = x + width;
+	r.top = y;
+	r.bottom = y + height;
+	
+	DWORD windowStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; 
+
+	AdjustWindowRect(&r, windowStyle, false);
+	
+	hWnd = CreateWindow(CONST_WINDOW_CLASS_NAME, title, windowStyle, 0, 0, r.right-r.left, r.bottom-r.top, NULL, NULL, hInstance, NULL);
+
+    if (hWnd == NULL) 
+	{
+		return false;
+    }
+
+    hDC = GetDC(hWnd);
+
+    memset(&pfd, 0, sizeof(pfd));
+    pfd.nSize = sizeof(pfd);
+    pfd.nVersion = 1;
+    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+    pfd.iPixelType = PFD_TYPE_RGBA;
+    pfd.cColorBits = 32;
+
+    pf = ChoosePixelFormat(hDC, &pfd);
+    if (pf == 0) 
+	{
+		return false;
+    } 
+ 
+    if (SetPixelFormat(hDC, pf, &pfd) == FALSE) 
+	{
+		return false;
+    } 
+
+    hRC = wglCreateContext( hDC );
+	wglMakeCurrent( hDC, hRC );
+
+    return true;
+}    
+
+int MainLoop(TApplication& application)
+{
+    MSG msg;
+
+	//Here console log is not created so we can not use ErrorCommon
+	try
+	{
+		Console = new TFileConsole(application.GetLogFilename());
+	}
+	catch(...)
+	{
+		exit(1);
+	}
+
+	//Here console log is already created
+	try
+	{
+
+	*Console<<"Log started";
+    
+	if (!CreateOpenGLWindow(application.WindowName.c_str(), application.X, application.Y, application.Width, application.Height,Hwnd,hDC,hRC))
+	{
+		*Console<<"Unable to create OpenGL Window!";
+		exit(1);
+	}
+
+	*Console<<"OpenGL Window created";
+
+	
+		if (App != NULL)
+			throw ErrorCommon();
+
+		App = &application;
+
+		Renderer = new THalibutRenderer;
+		ResourceManager = new THalibutResourceManager;
+
+		if (Renderer->BindOpenGLFunctions())
+		{
+			if (App->MatrixWidth == 0)
+			{
+				App->MatrixWidth = static_cast<float>(App->Width);
+			}
+
+			if (App->MatrixHeight == 0)
+			{
+				App->MatrixHeight = static_cast<float>(App->Height);
+			}
+
+			App->OuterInit(App->Width, App->Height, App->MatrixWidth, App->MatrixHeight);
+
+			ShowWindow(Hwnd, SW_SHOW);
+			UpdateWindow(Hwnd);
+
+			NewTickCount = GetTickCount();
+			LastTickCount = NewTickCount;
+
+			bool StayIn = true;
+
+			while (StayIn) 
+			{
+				while(PeekMessage(&msg, Hwnd, 0, 0, PM_NOREMOVE)) 
+				{
+					if(GetMessage(&msg, Hwnd, 0, 0)) 
+					{
+						TranslateMessage(&msg);
+						DispatchMessage(&msg);
+					} 
+					else
+					{
+						StayIn = false;
+					}
+				}
+				DrawScene();
+
+				ProcessTickCount();
+			}
+
+		}
+
+		*Console<<"Program prepares to quit";
+
+		App->OuterDeinit();
+
+		delete ResourceManager;
+		delete Renderer;
+
+
+		wglMakeCurrent(NULL, NULL);
+		ReleaseDC(Hwnd,hDC);
+		wglDeleteContext(hRC);
+		DestroyWindow(Hwnd);
+
+	}
+	catch(ErrorCommon)
+	{
+		//... let the ErrorTypes.h do the buisness
+	}
+
+
+	delete Console;
+
+	
+    return 0;
+}
+
+
+} //namespace SE

src/LightManager/LightManager.cpp

@@ -0,0 +1,53 @@
+#include "include/LightManager/LightManager.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+
+namespace SE
+{
+
+//===================================================
+//================ LIGHT MANAGER ====================
+//===================================================
+
+TLightManager::TLightManager()
+	: LightingEnabled(false)
+{
+}
+
+void TLightManager::SetLightPos(vec3 pos)
+{
+	LightPos = pos;
+}
+
+void TLightManager::SetLightDirection(vec3 dir)
+{
+	LightDirection = Normalize(dir);
+}
+
+void TLightManager::SetLightColor(vec4 color)
+{
+	LightColor = color;
+}
+
+
+void TLightManager::SetLightOn()
+{
+	LightingEnabled = true;
+}
+
+void TLightManager::SetLightOff()
+{
+	LightingEnabled = false;
+}
+
+void TLightManager::SetLightUniforms()
+{
+
+	RenderUniform3fv(CONST_STRING_LIGHT_POS_UNIFORM, LightPos.v);
+	RenderUniform3fv(CONST_STRING_LIGHT_DIRECTION_UNIFORM, LightDirection.v);
+	RenderUniform4fv(CONST_STRING_LIGHT_COLOR_UNIFORM, LightColor.v);
+}
+
+} //namespace SE

src/ModelManager/ModelManager.cpp

@@ -0,0 +1,361 @@
+#include "include/ModelManager/ModelManager.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+//===================================================
+//=========== LITE MODEL RESOURCE ===================
+//===================================================
+
+TLiteModelResource::~TLiteModelResource() 
+{
+	FreeModel();
+	*Console<<"ResourceManager::ModelManager::LiteModelResource deleting";
+}
+
+bool TLiteModelResource::LoadModel(boost::shared_array<byte> filePointer, cardinal fileSize)
+{
+
+	FreeModel();
+
+	cardinal triangleShift = *reinterpret_cast<cardinal*>(&filePointer[4]);
+
+	TriangleCount = *reinterpret_cast<cardinal*>(&filePointer[0] + triangleShift - 4);
+
+	int texnamelen = *reinterpret_cast<word*>(&filePointer[0] + 76);
+
+	Texname = std::string(reinterpret_cast<char*>(&filePointer[78]), reinterpret_cast<char*>(&filePointer[78]) + texnamelen);
+
+	int normtexnamelen = *reinterpret_cast<word*>(&filePointer[78]+texnamelen);
+
+	Normtexname = std::string(reinterpret_cast<char*>(&filePointer[80]+texnamelen), reinterpret_cast<char*>(&filePointer[80]+texnamelen) + normtexnamelen);
+
+	ResourceManager->TexList.AddTextureDirectly((PathToResource + std::string(Texname)));
+	if (Normtexname != "")
+	{
+		ResourceManager->TexList.AddTextureDirectly((PathToResource + std::string(Normtexname)));
+	}
+
+	VertexArr.resize(TriangleCount * 3);
+	NormalArr.resize(TriangleCount * 3);
+	TangentArr.resize(TriangleCount * 3);
+	BinormalArr.resize(TriangleCount * 3);
+	TexCoordArr.resize(TriangleCount * 3);
+
+	memcpy(&VertexArr[0], &filePointer[0] + triangleShift, TriangleCount * 36);
+	memcpy(&NormalArr[0], &filePointer[0] + triangleShift + TriangleCount * 36, TriangleCount * 36);
+	memcpy(&TangentArr[0], &filePointer[0] + triangleShift + TriangleCount * 72, TriangleCount * 36);
+	memcpy(&BinormalArr[0], &filePointer[0] + triangleShift + TriangleCount * 108, TriangleCount * 36);
+	memcpy(&TexCoordArr[0], &filePointer[0] + triangleShift + TriangleCount * 144, TriangleCount * 24);
+
+	return true;
+
+}
+
+void TLiteModelResource::FreeModel()
+{
+
+	if (Texname != "")
+	{
+		ResourceManager->TexList.DeleteTexture(GetFileName(Texname));
+		Texname = "";
+	}
+
+	if (Normtexname != "")
+	{
+		ResourceManager->TexList.DeleteTexture(GetFileName(Normtexname));
+		Normtexname = "";
+	}
+
+	VertexArr.clear();
+	NormalArr.clear();
+	TangentArr.clear();
+	BinormalArr.clear();
+	TexCoordArr.clear();
+
+}
+
+void TLiteModelResource::SetPathToResource(const std::string& pathToResource)
+{
+	PathToResource = pathToResource;
+}
+
+
+
+//===================================================
+//============= LITE MODEL REF ======================
+//===================================================
+TLiteModel::~TLiteModel() 
+{ 
+	FreeModel(); 
+	*Console<<"Render::LiteModel model deleting: " + Modelname;
+}
+
+bool TLiteModel::LoadModel(const std::string& s)
+{
+
+	TLiteModelResource& res = ResourceManager->ModelManager[s];
+
+	FreeModel();
+
+	Modelname = s;
+
+	TriangleCount = res.TriangleCount;
+
+	if (res.Texname != "")
+		TexID = ResourceManager->TexList[res.Texname];
+	else
+		TexID = 0;
+
+	if (res.Normtexname != "")
+		NormTexID = ResourceManager->TexList[res.Normtexname];
+	else
+		NormTexID = 0;
+
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB] = res.VertexArr;
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB] = res.NormalArr;
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB] = res.TangentArr;
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_BINORMAL_ATTRIB] = res.BinormalArr;
+	TriangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB] = res.TexCoordArr;
+
+	Loaded = true;
+
+	return true;
+}
+
+void TLiteModel::FreeModel()
+{
+	Loaded = false;
+
+	TriangleList.Data.Vec3CoordArr.clear();
+	TriangleList.Data.Vec2CoordArr.clear();
+#ifdef TARGET_WIN32
+	TriangleList.VertBufferArr.clear();
+#endif
+	TriangleCount = 0;
+	TexID = 0;
+	NormTexID = 0;
+
+	Modelname = "";
+}
+
+
+void TLiteModel::UpdateVBO()
+{
+	
+	CheckGlError();
+
+	TriangleList.RefreshBuffer();
+	
+	CheckGlError();
+
+}
+
+void TLiteModel::DrawImmediate()
+{
+	
+#ifdef TARGET_WIN32
+	
+	if (Loaded)
+	{
+		
+		int triangleCount = TriangleCount;
+
+		if (NormTexID == 0)
+		{
+			RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, 0);
+		}
+
+		RenderUniformMatrix3fv(CONST_STRING_MODELROTATEMATRIX_UNIFORM, false, ShaderRotateMatrix.m);
+		RenderUniform3fv(CONST_STRING_MODELTRANSLATEVECTOR_UNIFORM, ShaderTranslateVector.v);
+
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D, NormTexID);
+		
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, TexID);
+		
+		for (int i=0; i<triangleCount; i++)
+		{
+
+			
+
+			glBegin(GL_TRIANGLES);
+				VertexAttrib3fv(CONST_STRING_NORMAL_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][3*i]));
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][3*i]));
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_BINORMAL_ATTRIB][3*i]));
+				VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, (float*)(&TriangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][3*i]));
+				VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][3*i]));
+
+				VertexAttrib3fv(CONST_STRING_NORMAL_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][3*i + 1]));
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][3*i + 1]));
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_BINORMAL_ATTRIB][3*i + 1]));
+				VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, (float*)(&TriangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][3*i + 1]));
+				VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][3*i + 1]));
+
+				VertexAttrib3fv(CONST_STRING_NORMAL_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][3*i + 2]));
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][3*i + 2]));
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_BINORMAL_ATTRIB][3*i + 2]));
+				VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, (float*)(&TriangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB][3*i + 2]));
+				VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, (float*)(&TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][3*i + 2]));
+			glEnd();
+		}
+		
+	
+		RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, 1);
+
+	}
+#endif
+}
+
+void TLiteModel::DrawVBO()
+{
+	CheckGlError();
+	
+	if (NormTexID == 0)
+		RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM,0);
+
+	RenderUniformMatrix3fv(CONST_STRING_MODELROTATEMATRIX_UNIFORM,false,ShaderRotateMatrix.m);
+	RenderUniform3fv(CONST_STRING_MODELTRANSLATEVECTOR_UNIFORM,ShaderTranslateVector.v);
+
+	glActiveTexture(GL_TEXTURE1);
+	glBindTexture(GL_TEXTURE_2D,NormTexID);
+	
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,TexID);
+
+	Renderer->DrawTriangleList(TriangleList);
+
+	RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, 1);
+
+	CheckGlError();
+}
+
+
+
+
+void TLiteModel::MoveModel(const vec3& v)
+{
+	for (cardinal i = 0; i < TriangleCount * 3; i++)
+	{
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i] += v;
+	}
+}
+
+void TLiteModel::RotateModel(const mat3& r)
+{
+
+	for (cardinal i = 0; i < TriangleCount * 3; i++)
+	{
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i];
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][i];
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][i];
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_BINORMAL_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_BINORMAL_ATTRIB][i];
+	}
+}
+
+void TLiteModel::ScaleModel(float s)
+{
+
+	for (cardinal i = 0; i < TriangleCount * 3; i++)
+	{
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i] *= s;
+	}
+
+}
+
+
+void TLiteModel::ScaleModel(const vec3& s)
+{
+
+	for (cardinal i = 0; i < TriangleCount * 3; i++)
+	{
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i].v[0] *= s.v[0];
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i].v[1] *= s.v[1];
+		TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i].v[2] *= s.v[2];
+	}
+
+}
+
+void TLiteModel::SetShaderTranslateVector(const vec3& v)
+{
+	ShaderTranslateVector = v;
+}
+
+void TLiteModel::SetShaderRotateMatrix(const mat3& m)
+{
+	ShaderRotateMatrix = m;
+}
+
+
+//===================================================
+//=============== MODEL MANAGER =====================
+//===================================================
+
+TModelManager::~TModelManager() 
+{ 
+
+	Clear(); 
+
+	*Console<<"ResourceManager::ModelManager deleting"; 
+}
+
+void TModelManager::Clear()
+{
+	if (LiteModelMap.size() != 0)
+	{
+		LiteModelMap.clear();
+		*Console<<"ResourceManager::ModelManager cleared";
+	}
+}
+
+TLiteModelResource& TModelManager::operator[](const std::string& s)
+{
+	if (LiteModelMap.count(s) == 0)
+	{
+		throw ErrorToLog("Lite model with name " + s + " not loaded!");
+	}
+
+	return LiteModelMap[s];
+}
+
+bool TModelManager::AddLiteModel(const std::string& filename, const std::string& pathToResources)
+{
+	cardinal fileSize;
+	
+	std::string modelName = GetFileName(filename);
+
+	//If model already exists
+	if (LiteModelMap.count(modelName) != 0)
+		return true;
+
+	boost::shared_array<byte> fileArr = CreateMemFromFile<byte>((ResourceManager->PathToResources + filename), fileSize);
+
+	if (!(fileArr[0] == 'L' && fileArr[1] == 'M' && fileArr[2] == 0 && fileArr[3] == 1))
+		throw ErrorFileNotCorrect(filename);
+		
+
+	LiteModelMap[modelName].SetPathToResource(GetFilePath(ResourceManager->PathToResources + filename));
+
+	bool result = LiteModelMap[modelName].LoadModel(fileArr, fileSize);
+
+	if (!result)
+		throw ErrorFileNotLoaded(filename);
+
+	*Console<<"Lite model added successfully: "+filename;
+		
+	return true;
+}
+
+void TModelManager::DeleteLiteModel(const std::string& modelname)
+{
+	LiteModelMap.erase(modelname);
+	*Console<<"ResourceManager::ModelManager model deleted: "+modelname;
+}
+
+
+} //namespace SE

src/ModelManager/NewModelManager.cpp

@@ -0,0 +1,145 @@
+#include "include/ModelManager/NewModelManager.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+const int CONST_DATA_STACK_SIZE = 20;
+
+void TFlexModelResource::Serialize(boost::property_tree::ptree& propertyTree)
+{
+
+	BOOST_FOREACH(auto& ptree, propertyTree.get_child("Model.Vec3ArrMap"))
+	{
+
+		std::string name = ptree.second.get<std::string>("<xmlattr>.name");
+
+
+		BOOST_FOREACH(auto& vec3tree, ptree.second.get_child(""))
+		{
+			if (vec3tree.first == "Vec3")
+			{
+				DataTriangleList.Vec3CoordArr[name].push_back(StringToVec3(vec3tree.second.get<std::string>("")));
+			}
+		}
+	}
+
+	BOOST_FOREACH(auto& ptree, propertyTree.get_child("Model.Vec2ArrMap"))
+	{
+		std::string name = ptree.second.get<std::string>("<xmlattr>.name");
+
+		BOOST_FOREACH(auto& vec2tree, ptree.second.get_child(""))
+		{
+			if (vec2tree.first == "Vec2")
+			{
+				DataTriangleList.Vec2CoordArr[name].push_back(StringToVec2(vec2tree.second.get<std::string>("")));
+			}
+		}
+	}
+
+	BOOST_FOREACH(auto& ptree, propertyTree.get_child("Model.SamplerMap"))
+	{
+		if (ptree.first == "Sampler")
+		{
+			std::string name = ptree.second.get<std::string>("<xmlattr>.name");
+			std::string value = ptree.second.get<std::string>("<xmlattr>.value");
+
+			SamplerMap[name] = value;
+
+		}
+	}
+
+}
+
+
+
+void TFlexModel::PushModelDataTriangleList()
+{
+	if (DataTriangleListStack.size() == CONST_DATA_STACK_SIZE)
+	{
+		throw ErrorToLog("Error in TFlexModel::PushModelDataTriangleList - stack overflow!");
+	}
+
+	DataTriangleListStack.push(RenderPair.second.Data);
+}
+
+void TFlexModel::PopModelDataTriangleList()
+{
+	if (DataTriangleListStack.size() == 0)
+	{
+		throw ErrorToLog("Error in TFlexModel::PushModelDataTriangleList - stack underflow!");
+	}
+
+	RenderPair.second.Data = DataTriangleListStack.top();
+
+	DataTriangleListStack.pop();
+}
+
+void TFlexModel::MoveModel(const vec3& v)
+{
+	MoveDataTriangleList(RenderPair.second.Data, v);
+}
+
+void TFlexModel::RotateModel(const mat3& r)
+{
+	RotateDataTriangleList(RenderPair.second.Data, r);
+}
+
+void TFlexModel::ScaleModel(float s)
+{
+	ScaleDataTriangleList(RenderPair.second.Data, s);
+}
+
+void TFlexModel::ScaleModel(const vec3& s)
+{
+	ScaleDataTriangleList(RenderPair.second.Data, s);
+}
+
+void TFlexModel::RefreshBuffer()
+{
+	RenderPair.second.RefreshBuffer();
+}
+
+void TFlexModel::Draw()
+{
+	TRenderParamsSetter setter(RenderPair.first);
+
+	Renderer->DrawTriangleList(RenderPair.second);
+}
+
+
+void TFlexModelManager::LoadModelFromXml(std::string xmlFileName)
+{
+	TFlexModelResource model;
+
+	std::string modelName = GetFileName(xmlFileName);
+	std::string modelPath = GetFilePath(xmlFileName);
+
+	model.Serialize(*FileToPropertyTree(xmlFileName));
+
+	FlexModelResourceMap[modelName] = model;
+}
+
+TFlexModel TFlexModelManager::InstanciateModel(const std::string& modelName)
+{
+	if (FlexModelResourceMap.count(modelName) == 0)
+	{
+		throw ErrorToLog("Model not loaded: " + modelName);
+	}
+
+	TFlexModel model;
+
+	model.RenderPair.second.Data = FlexModelResourceMap[modelName].DataTriangleList;
+
+	model.RenderPair.second.RefreshBuffer();
+
+	model.RenderPair.first.SamplerMap = FlexModelResourceMap[modelName].SamplerMap;
+
+	return model;
+}
+
+
+
+} //namespace SE

src/OpenGLExt/OpenGlExt.cpp

@@ -0,0 +1,111 @@
+#include "include/OpenGlExt/OpenGlExt.h"
+
+namespace SE
+{
+
+//====================================================
+//===================== GLSL Shaders =================  
+//====================================================
+
+//Requires GL_VERSION_2_0
+PFNGLCREATEPROGRAMPROC glCreateProgram = NULL;  
+PFNGLDELETEPROGRAMPROC glDeleteProgram = NULL;  
+PFNGLLINKPROGRAMPROC glLinkProgram = NULL;  
+PFNGLVALIDATEPROGRAMPROC glValidateProgram = NULL;  
+PFNGLUSEPROGRAMPROC glUseProgram = NULL;  
+PFNGLGETPROGRAMIVPROC glGetProgramiv = NULL;  
+PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = NULL;  
+PFNGLCREATESHADERPROC glCreateShader = NULL;  
+PFNGLDELETESHADERPROC glDeleteShader = NULL;  
+PFNGLSHADERSOURCEPROC glShaderSource = NULL;  
+PFNGLCOMPILESHADERPROC glCompileShader = NULL;  
+PFNGLATTACHSHADERPROC glAttachShader = NULL;  
+PFNGLDETACHSHADERPROC glDetachShader = NULL;  
+PFNGLGETSHADERIVPROC glGetShaderiv = NULL;  
+PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = NULL;  
+PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation = NULL;  
+PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = NULL;  
+PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = NULL;  
+PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray = NULL;  
+PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation = NULL;  
+PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv = NULL;  
+PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv = NULL;  
+PFNGLUNIFORM1IPROC glUniform1i = NULL;  
+PFNGLUNIFORM1FVPROC glUniform1fv = NULL;  
+PFNGLUNIFORM3FVPROC glUniform2fv = NULL;  
+PFNGLUNIFORM3FVPROC glUniform3fv = NULL;  
+PFNGLUNIFORM4FVPROC glUniform4fv = NULL;  
+PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f = NULL;
+PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f = NULL;
+PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f = NULL;
+PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f = NULL;
+PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv = NULL;
+PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv = NULL;
+PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv = NULL;
+PFNGLGETACTIVEATTRIBPROC glGetActiveAttrib = NULL;
+PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform = NULL;
+
+
+//=======================================
+//=========== Multitexture ==============
+//=======================================
+
+//Requires GL version 1.3
+PFNGLACTIVETEXTUREPROC glActiveTexture = NULL;
+
+//=======================================
+//========== Vertex buffer ==============
+//=======================================
+
+//Requires GL_VERSION_1_5
+PFNGLGENBUFFERSPROC glGenBuffers = NULL;  
+PFNGLDELETEBUFFERSPROC glDeleteBuffers = NULL;  
+PFNGLBINDBUFFERPROC glBindBuffer = NULL;  
+PFNGLBUFFERDATAPROC glBufferData = NULL;  
+PFNGLBUFFERSUBDATAPROC glBufferSubData = NULL;  
+PFNGLMAPBUFFERPROC glMapBuffer = NULL;  
+PFNGLUNMAPBUFFERPROC glUnmapBuffer = NULL;  
+
+//=========================================
+//============ Frame buffer ===============
+//=========================================
+
+//Requires GL_ARB_framebuffer_object
+PFNGLISRENDERBUFFERPROC glIsRenderbuffer = NULL;
+PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer = NULL;
+PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers = NULL;
+PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers = NULL;
+PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage = NULL;
+PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv = NULL;
+PFNGLISFRAMEBUFFERPROC glIsFramebuffer = NULL;
+PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer = NULL;
+PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers = NULL;
+PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers = NULL;
+PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus = NULL;
+PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D = NULL;
+PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D = NULL;
+PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D = NULL;
+PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer = NULL;
+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv = NULL;
+PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer = NULL;
+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample = NULL;
+PFNGLGENERATEMIPMAPPROC glGenerateMipmap = NULL;
+PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer = NULL;
+
+
+
+//===========================================
+//============ Uniform buffer ===============
+//===========================================
+
+//Requires GL_ARB_uniform_buffer_object
+PFNGLGETUNIFORMINDICESPROC glGetUniformIndices = NULL;
+PFNGLGETACTIVEUNIFORMSIVPROC glGetActiveUniformsiv = NULL;
+PFNGLGETACTIVEUNIFORMNAMEPROC glGetActiveUniformName = NULL;
+PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex = NULL;
+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv = NULL;
+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glGetActiveUniformBlockName = NULL;
+PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding = NULL;
+PFNGLBINDBUFFERBASEPROC glBindBufferBase = NULL;
+
+} //namespace SE

src/Render/HalibutRender/HalibutRenderAndroid.cpp

@@ -0,0 +1,7 @@
+#include "include/Engine.h"
+#include "include/Render/HalibutRender/HalibutRenderAndroid.h"
+
+namespace SE
+{
+
+} //namespace SE

src/Render/HalibutRender/HalibutRenderGLES20.cpp

@@ -0,0 +1,50 @@
+#include "include/Engine.h"
+#include "include/Render/HalibutRender/HalibutRenderGLES20.h"
+
+namespace SE
+{
+
+THalibutRendererGLES20::THalibutRendererGLES20()
+{
+	ProjectionMatrixStack.push(IdentityMatrix4);
+	ModelviewMatrixStack.push(IdentityMatrix4);
+	*Console<<"Halibut Render created\n";
+}
+
+THalibutRendererGLES20::~THalibutRendererGLES20()
+{
+	*Console<<"Halibut Render destroying\n";
+}
+
+void THalibutRendererGLES20::DrawQuad(const T2DQuad& quad)
+{
+
+	VertexAttribPointer3fv(CONST_STRING_POSITION_ATTRIB, 0, reinterpret_cast<const char*>(quad.VertexCoord));
+	VertexAttribPointer2fv(CONST_STRING_TEXCOORD_ATTRIB, 0, reinterpret_cast<const char*>(quad.TextureCoord));
+   
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  
+}
+
+void THalibutRendererGLES20::DrawTriangleList(const TTriangleList& triangleList)
+{
+  
+	for (std::map<std::string, std::vector<vec2> >::iterator i = triangleList.Data.Vec2CoordArr.begin(); i != triangleList.Data.Vec2CoordArr.end(); ++i )
+	{
+		VertexAttribPointer2fv(i->first, 0, reinterpret_cast<const char*>(&triangleList.Data.Vec2CoordArr[i->first][0]));
+	}
+	
+	for (std::map<std::string, std::vector<vec3> >::iterator i = triangleList.Data.Vec3CoordArr.begin(); i != triangleList.Data.Vec3CoordArr.end(); ++i )
+	{
+		VertexAttribPointer3fv(i->first, 0, reinterpret_cast<const char*>(&triangleList.Data.Vec3CoordArr[i->first][0]));
+	}
+
+	if (!triangleList.Data.Vec3CoordArr.empty())
+	{
+		glDrawArrays(GL_TRIANGLES,0,triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size());
+	}
+
+}
+
+
+} //namespace SE

src/Render/HalibutRender/HalibutRenderInterface.cpp

@@ -0,0 +1,141 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+void THalibutRendererInterface::SetUniforms()
+{
+
+	if (ProjectionMatrixStack.size() <=0)
+	{
+		throw ErrorToLog("Projection matrix stack out!");
+	}
+	
+	if (ModelviewMatrixStack.size() <=0)
+	{
+		throw ErrorToLog("Modelview matrix stack out!");
+	}
+	
+	ProjectionModelviewMatrix = MultMatrixMatrix(ProjectionMatrixStack.top(), ModelviewMatrixStack.top());
+	RenderUniformMatrix4fv(CONST_STRING_HALIBUT_PROJECTION_MATRIX_UNIFORM, false, ProjectionModelviewMatrix.m);
+
+	//Refactoring!
+	
+	RenderUniform1i(CONST_STRING_TEXTURE_UNIFORM, 0);
+	RenderUniform1i(CONST_STRING_NORMALMAP_UNIFORM, 1);
+	
+	RenderUniform1f(CONST_STRING_TRANSPARENCY_UNIFORM, 1.f);
+	
+	RenderUniform4fv(CONST_STRING_MATERIAL_COLOR_UNIFORM, WhiteColor);
+	
+
+	/*
+	RenderUniform1i(CONST_STRING_SHADOWMAPGLOBAL_UNIFORM,2);
+	RenderUniform1i(CONST_STRING_SHADOWMAPLOCAL_UNIFORM,3);
+
+	RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM,1);
+	RenderUniform1i(CONST_STRING_ENV_UNIFORM,0);*/
+}
+
+void THalibutRendererInterface::InitOpenGL(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+
+	*Console<<"Halibut Render OpenGL init\n";
+	
+	#ifdef TARGET_WIN32
+	glEnable(GL_NORMALIZE);
+	glEnable(GL_TEXTURE_2D);
+	#endif
+	
+	glDisable(GL_DEPTH_TEST); 
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	
+	ScreenWidth = screenWidth;
+	ScreenHeight = screenHeight;
+	
+	MatrixWidth = matrixWidth;
+	MatrixHeight = matrixHeight;
+	
+	while (!ProjectionMatrixStack.empty())
+	{
+	   ProjectionMatrixStack.pop();
+    }
+	ProjectionMatrixStack.push(MakeOrthoMatrix(matrixWidth, matrixHeight));
+	
+    while (!ModelviewMatrixStack.empty())
+	{
+	   ModelviewMatrixStack.pop();
+    }
+	ModelviewMatrixStack.push(IdentityMatrix4);
+	
+	glViewport(0, 0, ScreenWidth, ScreenHeight);
+	
+	SetUniforms();
+	#ifndef TARGET_IOS
+	SwitchToScreen();
+	#endif
+
+	CheckGlError();
+
+}
+
+void THalibutRendererInterface::SwitchToScreen()
+{
+	//TODO: fix this stupid bug
+#ifdef TARGET_IOS
+    glBindFramebuffer(GL_FRAMEBUFFER, 2);
+#else
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+#endif
+	glViewport(0, 0, ScreenWidth, ScreenHeight);
+	SetProjectionMatrix(MatrixWidth, MatrixHeight);
+	SetUniforms();
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void THalibutRendererInterface::SwitchToFrameBuffer(const std::string& frameName)
+{
+	if (ResourceManager->FrameManager.FrameMap.count(frameName) > 0)
+	{
+		TFrame& Frame = ResourceManager->FrameManager.FrameMap[frameName];
+
+		glBindFramebuffer(GL_FRAMEBUFFER, Frame.FrameBuffer);
+		glViewport(0, 0, Frame.Width, Frame.Height);
+		SetProjectionMatrix(static_cast<float>(Frame.Width), static_cast<float>(Frame.Height));
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	}
+}
+
+void THalibutRendererInterface::PrintMatrices()
+{
+	mat4 proj = ProjectionMatrixStack.top();
+	mat4 modv = ModelviewMatrixStack.top();
+	*Console<<"Projection:\n ";
+	for (int i=0; i<16; i++)
+	{
+		*Console<<tostr(proj.m[i])<<" ";
+	}
+
+	*Console<<endl;
+	*Console<<"Modelview:\n ";
+	for (int i=0; i<16; i++)
+	{
+		*Console<<tostr(modv.m[i])<<" ";
+	}
+
+	modv = MultMatrixMatrix(proj, modv);
+
+	*Console<<endl;
+	*Console<<"ProjectonModelview:\n ";
+	for (int i=0; i<16; i++)
+	{
+		*Console<<tostr(modv.m[i])<<" ";
+	}
+
+	*Console<<endl;
+}
+
+} //namespace SE

src/Render/HalibutRender/HalibutRenderIos.cpp

@@ -0,0 +1,8 @@
+
+#include "include/Engine.h"
+
+
+namespace SE
+{
+
+} //namespace SE

src/Render/HalibutRender/HalibutRenderWindows.cpp

@@ -0,0 +1,312 @@
+#include "include/Engine.h"
+
+//Windows only!
+
+namespace SE
+{
+
+THalibutRenderer::THalibutRenderer()
+{
+	ScreenWidth = 0;
+	ScreenHeight = 0;
+
+	//To prevent stack out
+	ProjectionMatrixStack.push(IdentityMatrix4);
+	ModelviewMatrixStack.push(IdentityMatrix4);
+}
+
+THalibutRenderer::~THalibutRenderer()
+{
+	*Console<<"HalibutRender::deleting";
+}
+
+bool THalibutRenderer::BindOpenGLFunctions()
+{
+	char* extensionList = (char*)glGetString(GL_EXTENSIONS);
+	char* glVersion = (char*)glGetString(GL_VERSION);
+	bool ok = true;
+
+	*Console<<"Render::OpenGL glVersion = "+std::string(glVersion);
+	
+	//Requires OpenGL 2.0 or above
+	if (glVersion[0]>='2')
+	{
+		*Console<<"Render::OpenGL glVersion above 2.0 ok";
+
+		glActiveTexture = (PFNGLACTIVETEXTUREPROC) wglGetProcAddress("glActiveTexture");
+
+		glGenBuffers = (PFNGLGENBUFFERSPROC) wglGetProcAddress("glGenBuffers");
+		glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) wglGetProcAddress("glDeleteBuffers");
+		glBindBuffer = (PFNGLBINDBUFFERPROC) wglGetProcAddress("glBindBuffer");
+		glBufferData = (PFNGLBUFFERDATAPROC) wglGetProcAddress("glBufferData");
+		glBufferSubData = (PFNGLBUFFERSUBDATAPROC) wglGetProcAddress("glBufferSubData");
+		glMapBuffer = (PFNGLMAPBUFFERPROC) wglGetProcAddress("glMapBuffer");
+		glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) wglGetProcAddress("glUnmapBuffer");
+
+		glCreateProgram = (PFNGLCREATEPROGRAMPROC) wglGetProcAddress("glCreateProgram");
+		glDeleteProgram = (PFNGLDELETEPROGRAMPROC) wglGetProcAddress("glDeleteProgram");
+		glLinkProgram = (PFNGLLINKPROGRAMPROC) wglGetProcAddress("glLinkProgram");
+		glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) wglGetProcAddress("glValidateProgram");
+		glUseProgram = (PFNGLUSEPROGRAMPROC) wglGetProcAddress("glUseProgram");
+		glGetProgramiv = (PFNGLGETPROGRAMIVPROC) wglGetProcAddress("glGetProgramiv");
+		glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) wglGetProcAddress("glGetProgramInfoLog");
+		glCreateShader = (PFNGLCREATESHADERPROC) wglGetProcAddress("glCreateShader");
+
+ 
+		glDeleteShader = (PFNGLDELETESHADERPROC) wglGetProcAddress("glDeleteShader");
+		glShaderSource = (PFNGLSHADERSOURCEPROC) wglGetProcAddress("glShaderSource");
+		glCompileShader = (PFNGLCOMPILESHADERPROC) wglGetProcAddress("glCompileShader");
+		glAttachShader = (PFNGLATTACHSHADERPROC) wglGetProcAddress("glAttachShader");
+		glDetachShader = (PFNGLDETACHSHADERPROC) wglGetProcAddress("glDetachShader");
+		glGetShaderiv = (PFNGLGETSHADERIVPROC) wglGetProcAddress("glGetShaderiv");
+		glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) wglGetProcAddress("glGetShaderInfoLog");
+		glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) wglGetProcAddress("glGetAttribLocation");
+		glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) wglGetProcAddress("glVertexAttribPointer");
+		glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) wglGetProcAddress("glEnableVertexAttribArray");
+
+		glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) wglGetProcAddress("glDisableVertexAttribArray");
+		glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) wglGetProcAddress("glGetUniformLocation");
+		glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) wglGetProcAddress("glUniformMatrix3fv");
+		glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) wglGetProcAddress("glUniformMatrix4fv");
+		glUniform1i = (PFNGLUNIFORM1IPROC) wglGetProcAddress("glUniform1i");
+		glUniform1fv = (PFNGLUNIFORM1FVPROC) wglGetProcAddress("glUniform1fv");
+		glUniform2fv = (PFNGLUNIFORM2FVPROC) wglGetProcAddress("glUniform2fv");
+		glUniform3fv = (PFNGLUNIFORM3FVPROC) wglGetProcAddress("glUniform3fv");
+		glUniform4fv = (PFNGLUNIFORM4FVPROC) wglGetProcAddress("glUniform4fv");
+
+		glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) wglGetProcAddress("glVertexAttrib1f");
+		glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) wglGetProcAddress("glVertexAttrib2f");
+		glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) wglGetProcAddress("glVertexAttrib3f");
+		glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) wglGetProcAddress("glVertexAttrib4f");
+		glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) wglGetProcAddress("glVertexAttrib2fv");
+		glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) wglGetProcAddress("glVertexAttrib3fv");
+		glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) wglGetProcAddress("glVertexAttrib4fv");
+		glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) wglGetProcAddress("glGetActiveAttrib");
+		glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) wglGetProcAddress("glGetActiveUniform");
+
+		if (glActiveTexture==NULL ||
+			glGenBuffers==NULL ||
+			glDeleteBuffers==NULL ||
+			glBindBuffer==NULL ||
+			glBufferData==NULL ||
+			glBufferSubData==NULL ||
+			glMapBuffer==NULL ||
+			glCreateProgram==NULL ||
+			glDeleteProgram==NULL ||
+			glLinkProgram==NULL ||
+			glValidateProgram==NULL ||
+			glUseProgram==NULL ||
+			glGetProgramiv==NULL ||
+			glGetProgramInfoLog==NULL ||
+			glCreateShader==NULL ||
+			glDeleteShader==NULL ||
+			glShaderSource==NULL ||
+			glCompileShader==NULL ||
+			glAttachShader==NULL ||
+			glDetachShader==NULL ||
+			glGetShaderiv==NULL ||
+			glGetShaderInfoLog==NULL ||
+			glGetAttribLocation==NULL ||
+			glVertexAttribPointer==NULL ||
+			glEnableVertexAttribArray==NULL ||
+			glDisableVertexAttribArray==NULL ||
+			glGetUniformLocation==NULL ||
+			glUniformMatrix3fv==NULL ||
+			glUniformMatrix4fv==NULL ||
+			glUniform1i==NULL ||
+			glUniform1fv==NULL ||
+			glUniform2fv==NULL ||
+			glUniform3fv==NULL ||
+			glUniform4fv==NULL ||
+			glEnableVertexAttribArray==NULL ||
+			glVertexAttrib1f==NULL ||
+			glVertexAttrib2f==NULL ||
+			glVertexAttrib3f==NULL ||
+			glVertexAttrib4f==NULL ||
+			glVertexAttrib2fv==NULL ||
+			glVertexAttrib3fv==NULL ||
+			glVertexAttrib4fv==NULL ||
+			glGetActiveAttrib==NULL ||
+			glGetActiveUniform==NULL)
+		{
+			*Console<<"Render::OpenGL Some 2.0 version proc not found - starting failed";
+			ok = false;
+		}
+
+
+	}
+
+	else
+	{
+		*Console<<"Render::OpenGL glVersion below 2.0 - starting failed";
+		ok = false;
+	}
+	
+	if (findString("GL_ARB_framebuffer_object",extensionList))
+	{
+		*Console<<"Render::OpenGL GL_ARB_framebuffer_object supported ok";
+
+		glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) wglGetProcAddress("glIsRenderbuffer");
+		glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbuffer");
+		glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffers");
+		glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffers");
+		glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorage");
+		glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) wglGetProcAddress("glGetRenderbufferParameteriv");
+		glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) wglGetProcAddress("glIsFramebuffer");
+		glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebuffer");
+		glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffers");
+		glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffers");
+		glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatus");
+		glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) wglGetProcAddress("glFramebufferTexture1D");
+		glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2D");
+		glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) wglGetProcAddress("glFramebufferTexture3D");
+		glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbuffer");
+		glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) wglGetProcAddress("glGetFramebufferAttachmentParameteriv");
+		glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) wglGetProcAddress("glBlitFramebuffer");
+		glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) wglGetProcAddress("glRenderbufferStorageMultisample");
+		glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) wglGetProcAddress("glGenerateMipmap");
+		glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) wglGetProcAddress("glFramebufferTextureLayer");
+
+		if (glIsRenderbuffer == NULL ||
+			glBindRenderbuffer == NULL ||
+			glDeleteRenderbuffers == NULL ||
+			glGenRenderbuffers == NULL ||
+			glRenderbufferStorage == NULL ||
+			glGetRenderbufferParameteriv == NULL ||
+			glIsFramebuffer == NULL ||
+			glBindFramebuffer == NULL ||
+			glDeleteFramebuffers == NULL ||
+			glGenFramebuffers == NULL ||
+			glCheckFramebufferStatus == NULL ||
+			glFramebufferTexture1D == NULL ||
+			glFramebufferTexture2D == NULL ||
+			glFramebufferTexture3D == NULL ||
+			glFramebufferRenderbuffer == NULL ||
+			glGetFramebufferAttachmentParameteriv == NULL ||
+			glBlitFramebuffer == NULL ||
+			glRenderbufferStorageMultisample == NULL ||
+			glGenerateMipmap == NULL ||
+			glFramebufferTextureLayer == NULL)
+		{
+			*Console<<"Render::OpenGL Some GL_ARB_framebuffer_object proc not found - starting failed";
+			ok = false;
+		}
+
+
+	}
+	else
+	{
+		*Console<<"Render::OpenGL GL_ARB_framebuffer_object not supported - starting failed";
+		ok = false;
+	}
+
+#ifdef SALMON_WIN32
+	//Not needed for 2d engine
+
+	if (findString("GL_ARB_uniform_buffer_object",extensionList))
+	{
+
+		glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) wglGetProcAddress("glGetUniformIndices");
+		glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) wglGetProcAddress("glGetActiveUniformsiv");
+		glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) wglGetProcAddress("glGetActiveUniformName");
+		glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) wglGetProcAddress("glGetUniformBlockIndex");
+		glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) wglGetProcAddress("glGetActiveUniformBlockiv");
+		glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) wglGetProcAddress("glGetActiveUniformBlockName");
+		glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) wglGetProcAddress("glUniformBlockBinding");
+		glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) wglGetProcAddress("glBindBufferBase");
+
+		if (glGetUniformIndices == NULL ||
+			glGetActiveUniformsiv == NULL ||
+			glGetActiveUniformName == NULL ||
+			glGetUniformBlockIndex == NULL ||
+			glGetActiveUniformBlockiv == NULL ||
+			glGetActiveUniformBlockName == NULL ||
+			glUniformBlockBinding == NULL ||
+			glBindBufferBase == NULL)
+		{
+			*Console<<"Render::OpenGL some GL_ARB_uniform_buffer_object proc not found - starting failed";
+			ok = false;
+		}
+			
+		*Console<<"Render::OpenGL GL_ARB_uniform_buffer_object supported ok";
+	}
+	else
+	{
+		*Console<<"Render::OpenGL GL_ARB_uniform_buffer_object not supported - starting failed";
+		ok = false;
+	}
+
+#endif
+
+	return ok;
+}
+
+void THalibutRenderer::DrawQuad(const T2DQuad& quad)
+{
+	const float CONST_DEFAULT_NORM_VEC[3] = { 0.0f, 0.0f, 1.0f};
+
+	glBegin(GL_QUADS);
+		VertexAttrib3fv(CONST_STRING_NORMAL_ATTRIB, CONST_DEFAULT_NORM_VEC);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[0].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[0].v);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[1].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[1].v);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[3].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[3].v);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[2].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[2].v);
+	glEnd();
+}
+
+void THalibutRenderer::DrawTriangleStripImmediate(const TTriangleList& triangleList)
+{
+	const float CONST_DEFAULT_NORM_VEC[3] = { 0.0f, 0.0f, 1.0f};
+
+	int triangleCount = triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size()/3;
+
+	std::vector<vec3>::const_iterator vertexIterator = triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].begin();
+	std::vector<vec2>::const_iterator texcoordIterator = triangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].begin();
+
+	for (int i=0; i<triangleCount; i++)
+	{
+
+		glBegin(GL_TRIANGLES);
+			VertexAttrib3fv(CONST_STRING_NORMAL_ATTRIB, CONST_DEFAULT_NORM_VEC);
+			VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, (texcoordIterator++)->v);
+			VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, (vertexIterator++)->v);
+			VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, (texcoordIterator++)->v);
+			VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, (vertexIterator++)->v);
+			VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, (texcoordIterator++)->v);
+			VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, (vertexIterator++)->v);
+		glEnd();
+	}
+}
+
+
+
+void THalibutRenderer::DrawTriangleList(const TTriangleList& triangleList)
+{
+
+	//for (std::map<std::string, std::vector<vec2> >::iterator i = triangleList.Vec2CoordArr.begin(); i != triangleList.Vec2CoordArr.end(); ++i )
+	BOOST_FOREACH(auto& i, triangleList.Data.Vec2CoordArr)
+	{
+		glBindBuffer(GL_ARRAY_BUFFER, triangleList.VertBufferArr[i.first]->Buffer);
+		VertexAttribPointer2fv(i.first, 0, NULL);
+	}
+
+	//for (std::map<std::string, std::vector<vec3> >::iterator i = triangleList.Vec3CoordArr.begin(); i != triangleList.Vec3CoordArr.end(); ++i )
+	BOOST_FOREACH(auto& i, triangleList.Data.Vec3CoordArr)
+	{
+		glBindBuffer(GL_ARRAY_BUFFER, triangleList.VertBufferArr[i.first]->Buffer);
+		VertexAttribPointer3fv(i.first, 0, NULL);
+	}
+
+	if (!triangleList.Data.Vec3CoordArr.empty())
+	{
+		glDrawArrays(GL_TRIANGLES,0,triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size());
+	}
+
+}
+
+} //namespace SE
+	

src/Render/RenderInterface.cpp

@@ -0,0 +1,324 @@
+#include "include/Render/RenderInterface.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+TRendererInterface::TRendererInterface()
+	: ScreenWidth(0)
+	, ScreenHeight(0)
+{
+}
+
+void TRendererInterface::TryEnableVertexAttribArrays()
+{
+	EnableVertexAttribArray(CONST_STRING_POSITION_ATTRIB);
+	EnableVertexAttribArray(CONST_STRING_NORMAL_ATTRIB);
+	EnableVertexAttribArray(CONST_STRING_TEXCOORD_ATTRIB);
+	EnableVertexAttribArray(CONST_STRING_TANGENT_ATTRIB);
+	EnableVertexAttribArray(CONST_STRING_BINORMAL_ATTRIB);
+}
+
+void TRendererInterface::TryDisableVertexAttribArrays()
+{
+	DisableVertexAttribArray(CONST_STRING_BINORMAL_ATTRIB);
+	DisableVertexAttribArray(CONST_STRING_TANGENT_ATTRIB);	
+	DisableVertexAttribArray(CONST_STRING_TEXCOORD_ATTRIB);
+	DisableVertexAttribArray(CONST_STRING_NORMAL_ATTRIB);
+	DisableVertexAttribArray(CONST_STRING_POSITION_ATTRIB);
+}
+
+
+int TRendererInterface::GetScreenWidth() 
+{ 
+	return ScreenWidth; 
+}
+
+int TRendererInterface::GetScreenHeight() 
+{ 
+	return ScreenHeight; 
+}
+
+float TRendererInterface::GetMatrixWidth()
+{
+	return MatrixWidth;
+}
+
+
+float TRendererInterface::GetMatrixHeight()
+{
+	return MatrixHeight;
+}
+
+
+
+
+void TRendererInterface::SetScreenWidthHeight(int screenWidth, int screenHeight) 
+{ 
+	ScreenWidth = screenWidth; 
+	ScreenHeight = screenHeight; 
+}
+
+void TRendererInterface::PushMatrix()
+{
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+
+    ModelviewMatrixStack.push(ModelviewMatrixStack.top());
+    
+    if (ModelviewMatrixStack.size() > 64)
+    {
+        throw ErrorToLog("Modelview matrix stack overflow!!!!");
+    }
+}
+
+void TRendererInterface::LoadIdentity()
+{
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+
+    ModelviewMatrixStack.pop();
+    ModelviewMatrixStack.push(IdentityMatrix4);
+    
+    SetUniforms();
+}
+
+void TRendererInterface::TranslateMatrix(const vec3& p)
+{
+    mat4 m = IdentityMatrix4;
+    m.m[12] = p.v[0];
+    m.m[13] = p.v[1];
+    m.m[14] = p.v[2];
+    m = MultMatrixMatrix(ModelviewMatrixStack.top(), m);
+
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+
+    ModelviewMatrixStack.pop();
+    ModelviewMatrixStack.push(m);
+    
+    SetUniforms();
+}
+
+void TRendererInterface::ScaleMatrix(float scale)
+{
+    mat4 m = IdentityMatrix4;
+    m.m[0] = scale;
+    m.m[5] = scale;
+    m.m[10] = scale;
+    m = MultMatrixMatrix(ModelviewMatrixStack.top(), m);
+
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+
+    ModelviewMatrixStack.pop();
+    ModelviewMatrixStack.push(m);
+    
+    SetUniforms();
+}
+
+void TRendererInterface::ScaleMatrix(const vec3& scale)
+{
+	mat4 m = IdentityMatrix4;
+    m.m[0] = scale.v[0];
+    m.m[5] = scale.v[1];
+    m.m[10] = scale.v[2];
+    m = MultMatrixMatrix(ModelviewMatrixStack.top(), m);
+
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+
+    ModelviewMatrixStack.pop();
+    ModelviewMatrixStack.push(m);
+    
+    SetUniforms();
+}
+
+void TRendererInterface::RotateMatrix(const vec4& q)
+{
+    mat3 m3(q);
+    mat4 m = IdentityMatrix4;
+    m.m[0] = m3.m[0];
+    m.m[1] = m3.m[1];
+    m.m[2] = m3.m[2];
+    
+    m.m[4] = m3.m[3];
+    m.m[5] = m3.m[4];
+    m.m[6] = m3.m[5];
+    
+    m.m[8] = m3.m[6];
+    m.m[9] = m3.m[7];
+    m.m[10] = m3.m[8];
+    
+    m = MultMatrixMatrix(ModelviewMatrixStack.top(), m);
+
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+
+    ModelviewMatrixStack.pop();
+    ModelviewMatrixStack.push(m);
+    
+    SetUniforms();
+}
+
+void TRendererInterface::PushSpecialMatrix(const mat4& m)
+{
+	if (ModelviewMatrixStack.size() > 64)
+    {
+        throw ErrorToLog("Modelview matrix stack overflow!!!!");
+    }
+    ModelviewMatrixStack.push(m);
+    SetUniforms();
+}
+
+
+void TRendererInterface::PopMatrix()
+{
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+    ModelviewMatrixStack.pop();
+    
+    SetUniforms();
+}
+
+void TRendererInterface::PushProjectionMatrix(float width, float height)
+{
+    mat4 m = MakeOrthoMatrix(width, height);
+    ProjectionMatrixStack.push(m);
+    SetUniforms();
+    
+    if (ProjectionMatrixStack.size() > 64)
+    {
+        throw ErrorToLog("Projection matrix stack overflow!!!!");
+    }
+}
+
+void TRendererInterface::PopProjectionMatrix()
+{
+	if (ProjectionMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Projection matrix stack underflow!!!!");
+	}
+    ProjectionMatrixStack.pop();
+    SetUniforms();
+}
+
+void TRendererInterface::SetProjectionMatrix(float width, float height)
+{
+    mat4 m = MakeOrthoMatrix(width, height);
+	if (ProjectionMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Projection matrix stack underflow!!!!");
+	}
+    ProjectionMatrixStack.pop();
+    ProjectionMatrixStack.push(m);
+    SetUniforms();
+
+}
+
+void TRendererInterface::SetFrameViewport(const std::string& frameName)
+{
+	ivec2 frameWidthHeight = ResourceManager->FrameManager.GetFrameWidthHeight(frameName);
+	glViewport(0, 0, frameWidthHeight.v[0], frameWidthHeight.v[1]);
+}
+
+void TRendererInterface::SetFullScreenViewport()
+{
+	glViewport(0, 0, ScreenWidth, ScreenHeight);
+}
+
+void TRendererInterface::PushShader(const std::string& shaderName)
+{
+
+	ResourceManager->ShaderManager.PushShader(shaderName);
+	SetUniforms();
+	TryEnableVertexAttribArrays();
+}
+
+void TRendererInterface::PopShader()
+{
+
+	ResourceManager->ShaderManager.PopShader();
+	SetUniforms();
+	TryEnableVertexAttribArrays();
+
+}
+
+
+void TRendererInterface::DrawRect(const vec2& p1, const vec2& p2)
+{
+	T2DQuad quad;
+	
+	quad.VertexCoord[0] = vec3(p1.v[0], p1.v[1], 0.0f);
+	quad.VertexCoord[1] = vec3(p1.v[0], p2.v[1], 0.0f);
+	quad.VertexCoord[2] = vec3(p2.v[0], p1.v[1], 0.0f);
+	quad.VertexCoord[3] = vec3(p2.v[0], p2.v[1], 0.0f);
+
+	quad.TextureCoord[0] = vec2(0.01f, 0.01f);
+	quad.TextureCoord[1] = vec2(0.01f, 0.99f);
+	quad.TextureCoord[2] = vec2(0.99f, 0.01f);
+	quad.TextureCoord[3] = vec2(0.99f, 0.99f);
+
+	DrawQuad(quad);
+}
+
+void TRendererInterface::DrawRect(const vec2& p1, const vec2& p2, const vec2& t1, const vec2& t2)
+{
+	T2DQuad quad;
+	
+	quad.VertexCoord[0] = vec3(p1.v[0], p1.v[1], 0.0f);
+	quad.VertexCoord[1] = vec3(p1.v[0], p2.v[1], 0.0f);
+	quad.VertexCoord[2] = vec3(p2.v[0], p1.v[1], 0.0f);
+	quad.VertexCoord[3] = vec3(p2.v[0], p2.v[1], 0.0f);
+
+	quad.TextureCoord[0] = vec2(t1.v[0], t1.v[1]);
+	quad.TextureCoord[1] = vec2(t1.v[0], t2.v[1]);
+	quad.TextureCoord[2] = vec2(t2.v[0], t1.v[1]);
+	quad.TextureCoord[3] = vec2(t2.v[0], t2.v[1]);
+
+	DrawQuad(quad);
+}
+
+
+void TRendererInterface::DrawFrameFullScreen(const std::string& frameName)
+{
+
+	DrawFramePartScreen(frameName, vec2(0, 0), vec2(1, 1));
+}
+
+void TRendererInterface::DrawFramePartScreen(const std::string& frameName, vec2 posFrom, vec2 posTo)
+{
+
+	cardinal texID = ResourceManager->FrameManager.GetFrameTexture(frameName.c_str());
+
+	if (texID != 0)
+	{
+		PushProjectionMatrix(1,1);
+		
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+		LoadIdentity();
+		glBindTexture(GL_TEXTURE_2D,texID);
+
+		DrawRect(posFrom, posTo, posFrom, posTo);
+
+		PopProjectionMatrix();
+
+	}
+
+}
+
+} //namespace SE

src/Render/RenderMisc.cpp

@@ -0,0 +1,368 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+#ifdef TARGET_WIN32
+
+VBOObject::VBOObject()
+{
+	glGenBuffers(1, &Buffer);
+}
+
+VBOObject::VBOObject(const VBOObject& c)
+{
+	throw ErrorToLog("Copy constructor for VBOObject called\n");
+}
+
+	VBOObject& VBOObject::operator=(const VBOObject& c)
+{
+	throw ErrorToLog("operator= for VBOObject called\n");
+	return *this;
+}
+
+	VBOObject::~VBOObject()
+{
+	glDeleteBuffers(1, &Buffer);
+}
+
+
+#endif
+
+TDataTriangleList& TDataTriangleList::operator+=(const TDataTriangleList& dataTriangleList)
+{
+	BOOST_FOREACH(auto& i, dataTriangleList.Vec3CoordArr)
+	{
+		if (Vec3CoordArr.count(i.first) == 0)
+		{
+			Vec3CoordArr[i.first] = i.second;
+		}
+		else
+		{
+			Vec3CoordArr[i.first].insert(Vec3CoordArr[i.first].end(), i.second.begin(), i.second.end());
+		}
+	}
+
+	BOOST_FOREACH(auto& i, dataTriangleList.Vec2CoordArr)
+	{
+		if (Vec2CoordArr.count(i.first) == 0)
+		{
+			Vec2CoordArr[i.first] = i.second;
+		}
+		else
+		{
+			Vec2CoordArr[i.first].insert(Vec2CoordArr[i.first].end(), i.second.begin(), i.second.end());
+		}
+	}
+
+	return *this;
+}
+
+
+TTriangleListAncestor::TTriangleListAncestor()
+	: NeedRefreshBuffer(false)
+{
+}
+
+TTriangleListAncestor::TTriangleListAncestor(const TTriangleListAncestor& c)
+	: NeedRefreshBuffer(false)
+{
+	Data = c.Data;
+}
+
+TTriangleListAncestor& TTriangleListAncestor::operator=(const TTriangleListAncestor& c)
+{
+	Data = c.Data;
+	NeedRefreshBuffer = c.NeedRefreshBuffer;
+
+	return *this;
+}
+
+TTriangleListAncestor::TTriangleListAncestor(const TDataTriangleList& dataTriangleList)
+	: NeedRefreshBuffer(false)
+{
+	Data = dataTriangleList;
+}
+
+TTriangleListAncestor& TTriangleListAncestor::operator=(const TDataTriangleList& dataTriangleList)
+{
+	Data = dataTriangleList;
+	NeedRefreshBuffer = true;
+
+	return *this;
+}
+
+TTriangleListAncestor::~TTriangleListAncestor()
+{
+}
+
+
+#ifdef TARGET_WIN32
+
+TTriangleList::TTriangleList()
+	: TTriangleListAncestor()
+	, NeedPrepareBufferObjects(true)
+{
+}
+
+TTriangleList::~TTriangleList()
+{
+}
+
+void TTriangleList::RefreshBuffer()
+{
+	//VertBuffer
+
+
+	if (NeedPrepareBufferObjects && Data.Vec2CoordArr.size() > 0 && Data.Vec3CoordArr.size() > 0)
+	{
+
+		NeedPrepareBufferObjects = false;
+
+        BOOST_FOREACH(auto& i, Data.Vec2CoordArr)
+		{
+			if (VertBufferArr[i.first] == std::shared_ptr<VBOObject>())
+			{
+				VertBufferArr[i.first] = std::shared_ptr<VBOObject>(new VBOObject);
+				glBindBuffer(GL_ARRAY_BUFFER, VertBufferArr[i.first]->Buffer);
+
+				//What to do if buffer becomes empty?
+				if (i.second.size() > 0)
+				{
+					glBufferData(GL_ARRAY_BUFFER, i.second.size() * 8, &i.second[0], GL_STATIC_DRAW);
+				}
+				else
+				{
+					glBufferData(GL_ARRAY_BUFFER, 0, NULL, GL_STATIC_DRAW);
+				}
+			}
+		
+		}
+
+        BOOST_FOREACH(auto& i, Data.Vec3CoordArr)
+		//for (std::map<std::string, std::vector<vec3> >::iterator i = Data.Vec3CoordArr.begin(); i != Data.Vec3CoordArr.end(); ++i )
+		{
+			if (VertBufferArr[i.first] == std::shared_ptr<VBOObject>())
+			{
+				VertBufferArr[i.first] = std::shared_ptr<VBOObject>(new VBOObject);
+				glBindBuffer(GL_ARRAY_BUFFER, VertBufferArr[i.first]->Buffer);
+				
+				//What to do if buffer becomes empty?
+				if (i.second.size() > 0)
+				{
+					glBufferData(GL_ARRAY_BUFFER, i.second.size() * 12, &i.second[0], GL_STATIC_DRAW);
+				}
+				else
+				{
+					glBufferData(GL_ARRAY_BUFFER, 0, NULL, GL_STATIC_DRAW);
+				}
+			}
+
+		
+		}
+
+	}
+
+	
+	BOOST_FOREACH(auto& i, Data.Vec2CoordArr)
+    {
+		glBindBuffer(GL_ARRAY_BUFFER, VertBufferArr[i.first]->Buffer);
+		RefreshAttribBuffer2fv(i.first, Data.Vec2CoordArr);
+	}
+
+	BOOST_FOREACH(auto& i, Data.Vec3CoordArr)
+    {
+		glBindBuffer(GL_ARRAY_BUFFER, VertBufferArr[i.first]->Buffer);
+		RefreshAttribBuffer3fv(i.first, Data.Vec3CoordArr);
+	}
+
+
+}
+
+#endif
+    
+void FillVertexCoordVec(std::vector<vec3>& coordVec, int pos, vec2 posFrom, vec2 posTo)
+{
+    vec2 pos1 = posFrom;
+	vec2 pos2 = vec2(posFrom.v[0], posTo.v[1]);
+	vec2 pos3 = posTo;
+	vec2 pos4 = vec2(posTo.v[0], posFrom.v[1]);
+    
+    coordVec[pos] = vec3(pos1, 0);
+    coordVec[pos+1] = vec3(pos2, 0);
+    coordVec[pos+2] = vec3(pos3, 0);
+    coordVec[pos+3] = vec3(pos3, 0);
+    coordVec[pos+4] = vec3(pos4, 0);
+    coordVec[pos+5] = vec3(pos1, 0);
+ 
+}
+    
+void FillTexCoordVec(std::vector<vec2>& coordVec, int pos, vec2 texCoordFrom, vec2 texCoordTo)
+{
+    vec2 tex1 = texCoordFrom;
+	vec2 tex2 = vec2(texCoordFrom.v[0], texCoordTo.v[1]);
+	vec2 tex3 = texCoordTo;
+	vec2 tex4 = vec2(texCoordTo.v[0], texCoordFrom.v[1]);
+    
+    
+    coordVec[pos] = tex1;
+    coordVec[pos+1] = tex2;
+    coordVec[pos+2] = tex3;
+    coordVec[pos+3] = tex3;
+    coordVec[pos+4] = tex4;
+    coordVec[pos+5] = tex1;
+
+}
+
+
+std::vector<vec3> MakeVertexCoordVec(vec2 posFrom, vec2 posTo)
+{
+	std::vector<vec3> r;
+    r.resize(6);
+    
+    FillVertexCoordVec(r, 0, posFrom, posTo);
+
+	return r;
+}
+
+std::vector<vec2> MakeTexCoordVec(vec2 texCoordFrom, vec2 texCoordTo)
+{
+	std::vector<vec2> r;
+    r.resize(6);
+	FillTexCoordVec(r, 0, texCoordFrom, texCoordTo);
+    
+    return r;
+}
+
+
+TDataTriangleList MakeDataTriangleList(vec2 posFrom, vec2 posTo, vec2 texCoordFrom, vec2 texCoordTo)
+{
+	TDataTriangleList triangleList;
+
+	triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB] = MakeVertexCoordVec(posFrom, posTo);
+	triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB] = MakeTexCoordVec(texCoordFrom, texCoordTo);
+
+	return triangleList;
+}
+
+void MoveDataTriangleList(TDataTriangleList& triangleList, vec3 shift)
+{
+	if (triangleList.Vec3CoordArr.count(CONST_STRING_POSITION_ATTRIB) == 0)
+	{
+		return;
+	}
+
+    BOOST_FOREACH(auto& i, triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB])
+	{
+		i += shift;
+	}
+}
+
+void RotateDataTriangleList(TDataTriangleList& triangleList, const mat3& m)
+{
+	if (triangleList.Vec3CoordArr.count(CONST_STRING_POSITION_ATTRIB) == 0)
+	{
+		return;
+	}
+
+    BOOST_FOREACH(vec3& i, triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB])
+	{
+		i = i * m;
+	}
+}
+
+void ScaleDataTriangleList(TDataTriangleList& triangleList, float scale)
+{
+	if (triangleList.Vec3CoordArr.count(CONST_STRING_POSITION_ATTRIB) == 0)
+	{
+		return;
+	}
+
+    BOOST_FOREACH(vec3& i, triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB])
+	{
+		i.v[0] *= scale;
+		i.v[1] *= scale;
+		i.v[2] *= scale;
+	}
+}
+
+void ScaleDataTriangleList(TDataTriangleList& triangleList, vec3 scaleVec)
+{
+	if (triangleList.Vec3CoordArr.count(CONST_STRING_POSITION_ATTRIB) == 0)
+	{
+		return;
+	}
+
+    BOOST_FOREACH(vec3& i, triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB])
+	{
+		i.v[0] *= scaleVec.v[0];
+		i.v[1] *= scaleVec.v[1];
+		i.v[2] *= scaleVec.v[2];
+	}
+}
+
+TDataTriangleList& ClearDataTriangleList(TDataTriangleList& triangleList)
+{
+	//throw ErrorToLog("Seems that here are some problems with this func. Do not use it!");
+
+	BOOST_FOREACH(auto& i, triangleList.Vec2CoordArr)
+	{
+		i.second.clear();
+	}
+
+	BOOST_FOREACH(auto& i, triangleList.Vec3CoordArr)
+	{
+		i.second.clear();
+	}
+
+	return triangleList;
+}
+
+TDataTriangleList& InsertIntoDataTriangleList(TDataTriangleList& triangleList, const std::vector<vec3>& vertexArr, const std::vector<vec2>& texCoordArr)
+{
+	triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].insert(triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].end(), vertexArr.begin(), vertexArr.end());
+	triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].insert(triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].end(), texCoordArr.begin(), texCoordArr.end());
+				
+	return triangleList;
+}
+
+
+TTriangleList MakeTriangleList(vec2 posFrom, vec2 posTo, vec2 texCoordFrom, vec2 texCoordTo)
+{
+	TTriangleList triangleList;
+
+	triangleList.Data = MakeDataTriangleList(posFrom, posTo, texCoordFrom, texCoordTo);
+
+	triangleList.RefreshBuffer();
+
+	return triangleList;
+
+}
+    
+void Replace6PointsInTriangleList(TDataTriangleList& triangleList, int pos, vec2 posFrom, vec2 posTo, vec2 texCoordFrom, vec2 texCoordTo)
+{
+    FillVertexCoordVec(triangleList.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB], pos, posFrom, posTo);
+	FillTexCoordVec(triangleList.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB], pos, texCoordFrom, texCoordTo);
+}
+
+
+
+void CheckGlError(const std::string& msg)
+{
+	cardinal error = glGetError();
+	
+	if (error != GL_NO_ERROR)
+	{
+		if (msg == "")
+		{
+			throw ErrorToLog("Gl error = "+tostr(error));
+		}
+		else
+		{
+			throw ErrorToLog("Gl error = "+tostr(error) + "; with message = " + msg);
+		}
+	}
+}
+
+
+} //namespace SE

src/Render/RenderParams.cpp

@@ -0,0 +1,114 @@
+#include "include/Engine.h"
+#include "boost/lexical_cast.hpp"
+
+namespace SE
+{
+
+TRenderParamsSetter::TRenderParamsSetter(const TRenderParams& renderParams)
+	: RenderParams(renderParams)
+{
+	if (RenderParams.ShaderName != "")
+	{
+		Renderer->PushShader(RenderParams.ShaderName);
+	
+	}
+	else
+	{
+		Renderer->SetUniforms();
+	}
+
+	//Xperimental -- NEED TO DO SOMETHING WITH THIS, later!
+	glActiveTexture(GL_TEXTURE1);
+
+	if (RenderParams.SamplerMap.count(CONST_STRING_NORMALMAP_UNIFORM))
+	{
+		glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[RenderParams.SamplerMap[CONST_STRING_NORMALMAP_UNIFORM]]);
+	}
+	else
+	{
+		glBindTexture(GL_TEXTURE_2D, 0);
+	}
+
+	glActiveTexture(GL_TEXTURE0);
+
+	if (RenderParams.SamplerMap.count(CONST_STRING_TEXTURE_UNIFORM))
+	{
+		glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[RenderParams.SamplerMap[CONST_STRING_TEXTURE_UNIFORM]]);
+	}
+	else
+	{
+		glBindTexture(GL_TEXTURE_2D, 0);
+	}
+
+	for (std::map<std::string, float>::iterator i = RenderParams.FloatMap.begin(); i != RenderParams.FloatMap.end(); ++i)
+	{
+		RenderUniform1f(i->first, i->second);
+	}
+
+	for (std::map<std::string, vec4>::iterator i = RenderParams.Vec4Map.begin(); i != RenderParams.Vec4Map.end(); ++i)
+	{
+		RenderUniform4fv(i->first, i->second.v);
+	}
+}
+
+TRenderParamsSetter::~TRenderParamsSetter()
+{
+	if (RenderParams.ShaderName != "")
+	{
+		Renderer->PopShader();
+	}
+}
+
+/*
+	std::string ShaderName;
+
+	mutable std::map<std::string, std::string> SamplerMap;
+	mutable std::map<std::string, float> FloatMap;
+	mutable std::map<std::string, vec4> Vec4Map;
+	*/
+void TRenderParams::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	if (propertyTree.count("Shader") != 0)
+	{
+		ShaderName = propertyTree.get<std::string>("Shader");
+	}
+
+	if (propertyTree.count("SamplerMap") != 0)
+	{
+		SamplerMap.clear();
+
+		TMapParser<std::string, std::string> mapParser;
+
+		mapParser.Serialize(propertyTree.get_child("SamplerMap"));
+
+		SamplerMap = mapParser.Map;
+	}
+
+	if (propertyTree.count("FloatMap") != 0)
+	{
+		SamplerMap.clear();
+
+		TMapParser<std::string, float> mapParser;
+
+		mapParser.Serialize(propertyTree.get_child("FloatMap"));
+
+		FloatMap = mapParser.Map;
+	}
+
+	if (propertyTree.count("Vec4Map") != 0)
+	{
+		SamplerMap.clear();
+
+		TMapParser<std::string, std::string> mapParser;
+
+		mapParser.Serialize(propertyTree.get_child("Vec4Map"));
+
+		for (std::map<std::string, std::string>::iterator i = mapParser.Map.begin(); i != mapParser.Map.end(); ++i)
+		{
+			Vec4Map[i->first] = StringToVec4(i->second);
+		}
+
+	}
+}
+
+} //namespace SE

src/Render/SalmonRender/BackgroundCubemap.cpp

@@ -0,0 +1,118 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+const float CONST_CUBEMAP_SIDE = 50.0f;
+
+TBackgroundCubemapClass::TBackgroundCubemapClass()
+{
+
+
+	vec3 pos1 = vec3(-CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	vec3 pos2 = vec3(-CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	vec3 pos3 = vec3(-CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+	vec3 pos4 = vec3(-CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos2);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos4);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+
+	pos1 = vec3(CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos2 = vec3(CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos3 = vec3(CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+	pos4 = vec3(CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos2);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos4);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+
+	pos1 = vec3(-CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos2 = vec3(CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos3 = vec3(CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+	pos4 = vec3(-CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos2);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos4);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+
+	pos1 = vec3(-CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos2 = vec3(CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos3 = vec3(CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+	pos4 = vec3(-CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos2);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos4);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+
+	pos1 = vec3(-CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos2 = vec3(CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos3 = vec3(CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+	pos4 = vec3(-CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos2);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos4);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+
+	pos1 = vec3(-CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE);
+	pos2 = vec3(CONST_CUBEMAP_SIDE, -CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE);
+	pos3 = vec3(CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE);
+	pos4 = vec3(-CONST_CUBEMAP_SIDE,  CONST_CUBEMAP_SIDE, CONST_CUBEMAP_SIDE);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos2);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos3);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos4);
+	TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].push_back(pos1);
+
+	TriangleList.Data.Vec2CoordArr[CONST_STRING_TEXCOORD_ATTRIB].resize(36); //Texture coords actually not in use
+
+
+	TriangleList.RefreshBuffer();
+}
+
+
+void TBackgroundCubemapClass::Draw()
+{
+	
+	mat4 m = Renderer->GetModelviewMatrix();
+
+	m.m[12] = 0.f;
+	m.m[13] = 0.f;
+	m.m[14] = 0.f;
+
+	Renderer->PushSpecialMatrix(m);
+
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_CUBE_MAP, BkgTexId);
+
+	Renderer->DrawTriangleList(TriangleList);
+	Renderer->PopMatrix();
+
+}
+
+} //namespace SE

src/Render/SalmonRender/SalmonRenderAndroid.cpp

@@ -0,0 +1,9 @@
+#include "include/Render/SalmonRender/SalmonRenderAndroid.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+} //namespace SE

src/Render/SalmonRender/SalmonRenderGLES20.cpp

@@ -0,0 +1,44 @@
+#include "include/Render/SalmonRender/SalmonRenderAndroid.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+void TSalmonRendererGLES20::DrawQuad(const T2DQuad& quad)
+{
+	//EnableVertexAttribArray("vPosition");
+	//EnableVertexAttribArray("vTexCoord");
+	
+	VertexAttribPointer3fv("vPosition", 0, reinterpret_cast<const char*>(quad.VertexCoord));
+	VertexAttribPointer2fv("vTexCoord", 0, reinterpret_cast<const char*>(quad.TextureCoord));
+   
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  
+	//DisableVertexAttribArray("vPosition");
+	//DisableVertexAttribArray("vTexCoord");
+}
+
+
+
+void TSalmonRendererGLES20::DrawTriangleList(const TTriangleList& triangleList)
+{
+	for (std::map<std::string, std::vector<vec2> >::iterator i = triangleList.Data.Vec2CoordArr.begin(); i != triangleList.Data.Vec2CoordArr.end(); ++i )
+	{
+		VertexAttribPointer2fv(i->first, 0, reinterpret_cast<const char*>(&triangleList.Data.Vec2CoordArr[i->first][0]));
+	}
+	
+	for (std::map<std::string, std::vector<vec3> >::iterator i = triangleList.Data.Vec3CoordArr.begin(); i != triangleList.Data.Vec3CoordArr.end(); ++i )
+	{
+		VertexAttribPointer3fv(i->first, 0, reinterpret_cast<const char*>(&triangleList.Data.Vec3CoordArr[i->first][0]));
+	}
+
+	if (!triangleList.Data.Vec3CoordArr.empty())
+	{
+		glDrawArrays(GL_TRIANGLES,0,triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size());
+	}
+
+}
+
+} //namespace SE

src/Render/SalmonRender/SalmonRenderInterface.cpp

@@ -0,0 +1,810 @@
+#include "include/Render/SalmonRender/SalmonRenderInterface.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+
+TSalmonRendererInterface::TSalmonRendererInterface()
+	: CamAlpha(0.0f)
+	, CamPhi(0.0f)
+	, CamDist(0.0f)
+	, CamShift(ZeroVec3)
+	, GlobalShadowAreaHalfSize(CONST_DEFAULT_GLOBAL_SHADOW_AREA_HALFSIZE)
+{
+	ProjectionMatrixStack.push(IdentityMatrix4);
+	
+	ModelviewMatrixStack.push(IdentityMatrix4);
+
+}
+
+
+void TSalmonRendererInterface::SetUniforms()
+{
+
+	//Refactoring!
+	
+
+	if (ProjectionMatrixStack.size() <=0)
+	{
+		throw ErrorToLog("Projection matrix stack out!");
+	}
+	
+	if (ModelviewMatrixStack.size() <=0)
+	{
+		throw ErrorToLog("Modelview matrix stack out!");
+	}
+	
+	ProjectionModelviewMatrix = MultMatrixMatrix(ProjectionMatrixStack.top(), ModelviewMatrixStack.top());
+	RenderUniformMatrix4fv(CONST_STRING_HALIBUT_PROJECTION_MATRIX_UNIFORM, false, ProjectionModelviewMatrix.m);
+
+		//TODO: Make a new name =(
+	RenderUniformMatrix4fv("ProjectionMatrix1", false, ProjectionMatrixStack.top().m);
+
+	RenderUniform1i(CONST_STRING_TEXTURE_UNIFORM,0);
+	RenderUniform1i(CONST_STRING_NORMALMAP_UNIFORM,1);
+	RenderUniform1i(CONST_STRING_SHADOWMAPGLOBAL_UNIFORM,2);
+	RenderUniform1i(CONST_STRING_SHADOWMAPLOCAL_UNIFORM,3);
+
+	RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM,1);
+	RenderUniform1i(CONST_STRING_ENV_UNIFORM,0);
+
+	//RenderUniform1f(CONST_STRING_SHADOWCLAMPVALUE_UNIFORM, GetShadowClampValue());
+	//RenderUniform1i(CONST_STRING_ACTIVELIGHTCOUNT_UNIFORM, ResourceManager->LightManager.GetActiveLightCount());
+
+	//RenderUniform1f(CONST_STRING_FOG_BEGIN_DISTANCE_UNIFORM, GetFogBeginDistance());
+	//RenderUniform1f(CONST_STRING_FOG_END_DISTANCE_UNIFORM, GetFogEndDistance());
+	//RenderUniform4fv(CONST_STRING_FOG_COLOR_UNIFORM, GetFogColor().v);
+
+	RenderUniform3fv(CONST_STRING_CAMPOS_UNIFORM, GetCamPos().v);
+
+	ResourceManager->LightManager.SetLightUniforms();
+}
+
+
+void TSalmonRendererInterface::InitOpenGL(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+	
+	ModelviewMatrixStack.push(IdentityMatrix4);
+	ProjectionMatrixStack.push(IdentityMatrix4);
+
+	ScreenWidth = screenWidth;
+	ScreenHeight = screenHeight;
+
+	MatrixWidth = matrixWidth;
+	MatrixHeight = matrixHeight;
+
+	SetPerspectiveProjectionMatrix(pi / 6.f, 1.0, 1.0f, 100.0f); //Baad =(
+
+	SetPerspectiveFullScreenViewport();
+
+	glEnable(GL_DEPTH_TEST);
+	#ifdef TARGET_WIN32
+	glEnable(GL_LIGHTING);
+	glEnable(GL_NORMALIZE);
+	glEnable(GL_TEXTURE_2D);
+	glEnable(GL_BLEND);
+	glMaterialfv(GL_FRONT, GL_DIFFUSE, WhiteColor);
+	
+	glPolygonMode(GL_FRONT_AND_BACK , GL_FILL);
+	#endif
+
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	CheckGlError();
+
+}
+
+
+void TSalmonRendererInterface::CalcCamPosVec()
+{
+
+	float sina = sinf(CamAlpha);
+	float cosa = cosf(CamAlpha);
+	float sinp = sinf(CamPhi);
+	float cosp = cosf(CamPhi);
+
+	CamVec.v[0] = CamDist * cosp * sina;
+	CamVec.v[1] = - CamDist * sinp;
+	CamVec.v[2] = - CamDist * cosp * cosa;
+
+	CamPos = CamShift - CamVec;
+
+	RenderUniform3fv(CONST_STRING_CAMPOS_UNIFORM,(float*)&CamPos);
+}
+
+void TSalmonRendererInterface::SetPerspectiveFullScreenViewport()
+{
+
+	glViewport(0, 0, ScreenWidth, ScreenHeight);
+
+	SetPerspectiveProjectionMatrix(pi / 6.f, float(MatrixWidth) / float(MatrixHeight), 1.0f, 100.0f);
+}
+
+void TSalmonRendererInterface::SetOrthoFullScreenViewport()
+{
+
+	glViewport(0, 0, ScreenWidth, ScreenHeight);
+
+	SetProjectionMatrix(static_cast<float>(MatrixWidth), static_cast<float>(MatrixHeight));
+}
+
+
+mat4 TSalmonRendererInterface::GetModelviewMatrix()
+{
+	if (ModelviewMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Modelview matrix stack underflow!!!!");
+	}
+    return ModelviewMatrixStack.top();
+}
+
+
+void TSalmonRendererInterface::SetPerspectiveProjectionMatrix(float angle, float aspect, float zNear, float zFar)
+{
+	mat4 m = MakePerspectiveMatrix(angle, aspect, zNear, zFar);
+
+	if (ProjectionMatrixStack.size() == 0)
+	{
+		throw ErrorToLog("Projection matrix stack underflow!!!!");
+	}
+    ProjectionMatrixStack.pop();
+    ProjectionMatrixStack.push(m);
+    SetUniforms();
+}
+
+void TSalmonRendererInterface::PushPerspectiveProjectionMatrix(float angle, float aspect, float zNear, float zFar)
+{
+	mat4 m = MakePerspectiveMatrix(angle, aspect, zNear, zFar);
+	
+    ProjectionMatrixStack.push(m);
+
+	if (ProjectionMatrixStack.size() > 64)
+    {
+        throw ErrorToLog("Projection matrix stack overflow!!!!");
+    }
+
+    SetUniforms();
+}
+
+
+
+
+
+void TSalmonRendererInterface::SetGLCamView()
+{
+	/*
+	glLoadIdentity();
+	glTranslatef(0.0f, 0.0f, -CamDist);
+	glRotatef(CamPhi*180.0f/pi, 1.0f, 0.0f, 0.0f);
+	glRotatef(CamAlpha*180.0f/pi, 0.0f, 1.0f, 0.0f);
+
+	//TODO
+	glTranslatef(-CamShift.v[0], -CamShift.v[1], -CamShift.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	RenderUniform3fv(CONST_STRING_CAMPOS_UNIFORM,CamPos.v);*/
+
+	LoadIdentity();
+	TranslateMatrix(vec3(0.0f, 0.0f, -CamDist));
+	RotateMatrix(vec4(1.f * sin(CamPhi/2.f), 0.f, 0.f, 1.f * cos(CamPhi/2.f)));
+	RotateMatrix(vec4(0.f, 1.f * sin(CamAlpha/2.f), 0.f, 1.f * cos(CamAlpha/2.f)));
+	TranslateMatrix(-CamShift);
+
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+}
+
+void TSalmonRendererInterface::SetGlIdentityView()
+{
+	/*
+	glLoadIdentity();
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	RenderUniform3fv(CONST_STRING_CAMPOS_UNIFORM, (float*)ZeroVec3.v);*/
+
+	LoadIdentity();
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+}
+
+void TSalmonRendererInterface::SetGlPosXView()
+{
+	/*
+	glLoadIdentity();
+	glRotatef (  90.0, 0.0, 1.0, 0.0 );
+    glRotatef ( 180.0, 1.0, 0.0, 0.0 );
+	glTranslatef(-CamPos.v[0], -CamPos.v[1], -CamPos.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);*/
+
+	LoadIdentity();
+
+	RotateMatrix(vec4(0.f, 1.f * sin(pi / 4.f), 0.f, 1.f * cos(pi / 4.f)));
+	RotateMatrix(vec4(1.f * sin(pi / 2.f), 0.f, 0.f, 1.f * cos(pi / 2.f)));
+	
+	TranslateMatrix(-CamShift);
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+
+}
+
+void TSalmonRendererInterface::SetGlNegXView()
+{
+	/*
+	glLoadIdentity();
+	glRotatef ( -90.0, 0.0, 1.0, 0.0 );
+    glRotatef ( 180.0, 1.0, 0.0, 0.0 );
+	glTranslatef(-CamPos.v[0], -CamPos.v[1], -CamPos.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);*/
+
+	LoadIdentity();
+
+	RotateMatrix(vec4(0.f, -1.f * sin(pi / 4.f), 0.f, 1.f * cos(pi / 4.f)));
+	RotateMatrix(vec4(1.f * sin(pi / 2.f), 0.f, 0.f, 1.f * cos(pi / 2.f)));
+	
+	TranslateMatrix(-CamShift);
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+}
+
+void TSalmonRendererInterface::SetGlPosYView()
+{
+	/*
+	glLoadIdentity();
+	glRotatef ( -90.0, 1.0, 0.0, 0.0 );
+	glTranslatef(-CamPos.v[0], -CamPos.v[1], -CamPos.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);*/
+
+	LoadIdentity();
+	RotateMatrix(vec4(-1.f * sin(pi / 4.f), 0.f, 0.f, 1.f * cos(pi / 4.f)));
+	
+	TranslateMatrix(-CamShift);
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+
+}
+
+void TSalmonRendererInterface::SetGlNegYView()
+{
+	/*
+	glLoadIdentity();
+	glRotatef (  90.0, 1.0, 0.0, 0.0 );
+	glTranslatef(-CamPos.v[0], -CamPos.v[1], -CamPos.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);*/
+
+	LoadIdentity();
+	RotateMatrix(vec4(1.f * sin(pi / 4.f), 0.f, 0.f, 1.f * cos(pi / 4.f)));
+	
+	TranslateMatrix(-CamShift);
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+}
+
+void TSalmonRendererInterface::SetGlPosZView()
+{
+	/*
+	glLoadIdentity();
+	glRotatef ( 180.0, 0.0, 1.0, 0.0 );
+	glRotatef ( 180.0, 0.0, 0.0, 1.0 );
+	glTranslatef(-CamPos.v[0], -CamPos.v[1], -CamPos.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+	*/
+
+	LoadIdentity();
+
+	RotateMatrix(vec4(0.f, 1.f * sin(pi / 2.f), 0.f, 1.f * cos(pi / 2.f)));
+	RotateMatrix(vec4(0.f, 0.f, 1.f * sin(pi / 2.f), 1.f * cos(pi / 2.f)));
+	
+	TranslateMatrix(-CamShift);
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+}
+
+void TSalmonRendererInterface::SetGlNegZView()
+{
+	/*
+	glLoadIdentity();
+	glRotatef ( 180.0, 0.0, 0.0, 1.0 );
+	glTranslatef(-CamPos.v[0], -CamPos.v[1], -CamPos.v[2]);
+
+	glGetFloatv(GL_MODELVIEW_MATRIX,CamModelViewMatrix.m);
+
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);*/
+
+	LoadIdentity();
+
+	RotateMatrix(vec4(0.f, 0.f, 1.f * sin(pi / 2.f), 1.f * cos(pi / 2.f)));
+	
+	TranslateMatrix(-CamShift);
+	
+	CamModelViewMatrix = ModelviewMatrixStack.top();
+	CamInversedModelViewMatrix = InverseModelViewMatrix(CamModelViewMatrix);
+
+	SetUniforms();
+
+}
+
+
+vec3 TSalmonRendererInterface::GetCamPos() 
+{ 
+	return CamPos; 
+}
+
+
+void TSalmonRendererInterface::MoveAlpha(float dAlpha) 
+{ 
+	if (dAlpha == 0.0f)
+		return;
+
+	CamAlpha += dAlpha; 
+
+	while (CamAlpha >= 2*pi) 
+	{
+		CamAlpha -= 2*pi; 
+	}
+
+	while (CamAlpha<0.0f)
+	{
+		CamAlpha += 2*pi;
+	}
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}
+	*/
+}
+
+void TSalmonRendererInterface::MovePhi(float dPhi) 
+{ 
+	if (dPhi == 0.0f)
+		return;
+
+	//float oldCamPhi = CamPhi;
+	CamPhi += dPhi;
+	
+	if (CamPhi > CONST_MAX_CAM_PHI) 
+	{
+		CamPhi = CONST_MAX_CAM_PHI;
+	}
+	
+	if (CamPhi < CONST_MIN_CAM_PHI)
+	{
+		CamPhi = CONST_MIN_CAM_PHI;
+	}
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}*/
+	
+}
+
+void TSalmonRendererInterface::MoveDist(float dDist)
+{ 
+	CamDist += dDist; /*
+	if (CamDist>CONST_MAX_CAM_DIST) 
+	{
+		CamDist = CONST_MAX_CAM_DIST; 
+	}*/
+	
+	if (CamDist<CONST_MIN_CAM_DIST) 
+	{
+		CamDist = CONST_MIN_CAM_DIST; 
+	}
+
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}*/
+
+}
+
+
+void TSalmonRendererInterface::SetAlpha(float alpha)
+{
+	if (alpha == CamAlpha)
+		return;
+
+	CamAlpha = alpha; 
+
+	while (CamAlpha >= 2*pi) 
+	{
+		CamAlpha -= 2*pi; 
+	}
+
+	while (CamAlpha<0.0f)
+	{
+		CamAlpha += 2*pi;
+	}
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+}
+
+void TSalmonRendererInterface::MoveForward()
+{
+	vec3 mov;
+	
+	float sina = sinf(CamAlpha);
+	float cosa = cosf(CamAlpha);
+
+	mov.v[0] = sina;
+	mov.v[1] = 0;
+	mov.v[2] = - cosa;
+
+	CamShift = CamShift + mov;
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}*/
+	
+}
+
+void TSalmonRendererInterface::MoveBackward()
+{
+	vec3 mov;
+	
+	float sina = sinf(CamAlpha);
+	float cosa = cosf(CamAlpha);
+
+	mov.v[0] = - sina;
+	mov.v[1] = 0;
+	mov.v[2] = cosa;
+
+	CamShift = CamShift + mov;
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}*/
+	
+}
+
+void TSalmonRendererInterface::MoveLeft()
+{
+	vec3 mov;
+	
+	float sina = sinf(CamAlpha);
+	float cosa = cosf(CamAlpha);
+
+	mov.v[0] = - cosa;
+	mov.v[1] = 0;
+	mov.v[2] = - sina;
+
+	CamShift = CamShift + mov;
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}
+	*/
+}
+
+void TSalmonRendererInterface::MoveRight()
+{
+	vec3 mov;
+	
+	float sina = sinf(CamAlpha);
+	float cosa = cosf(CamAlpha);
+
+	mov.v[0] = cosa;
+	mov.v[1] = 0;
+	mov.v[2] = sina;
+
+	CamShift = CamShift + mov;
+	
+	//Possibly refactor???
+	CalcCamPosVec();
+	/*
+	if (!IsCameraTransparentToLand && LandToCalcCollision->IsOnTheLand(CamPos))
+	{
+		CamPhi -= CONST_CAMERA_PHI_ELEVATION_STEP;
+		
+		CalcCamPosVec();
+		
+		float h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+		
+		if (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+		{
+			CamPhi = CONST_MIN_CAM_PHI;
+
+			CalcCamPosVec();
+
+			h = LandToCalcCollision->CalcVerticalCrossingFast(CamPos);
+
+			while (h + CONST_CAMERA_VERTICAL_SHIFT > CamPos.v[1])
+			{
+				CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+				CalcCamPosVec();
+			}
+		}
+		else
+		{
+			CamPhi += CONST_CAMERA_PHI_ELEVATION_STEP;
+			CalcCamPosVec();
+		}
+	}*/
+	
+}
+
+
+
+void TSalmonRendererInterface::SwitchToScreen()
+{
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	SetPerspectiveFullScreenViewport();
+	SetGLCamView();
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void TSalmonRendererInterface::SwitchToFrameBuffer(const std::string& frameName)
+{
+	
+	if (ResourceManager->FrameManager.FrameMap.count(frameName) > 0)
+	{
+		TFrame Frame = ResourceManager->FrameManager.FrameMap[frameName];
+
+		glBindFramebuffer(GL_FRAMEBUFFER, Frame.FrameBuffer);
+
+		SetFrameViewport(frameName);
+
+		SetGLCamView();
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	}
+}
+
+void TSalmonRendererInterface::SwitchToCubemapBuffer(const std::string& frameName,cardinal cubeSide)
+{
+
+	
+	if (ResourceManager->FrameManager.FrameMap.count(frameName) > 0)
+	{
+		TFrame Frame = ResourceManager->FrameManager.FrameMap[frameName];
+
+		glBindFramebuffer(GL_FRAMEBUFFER, Frame.FrameBuffer);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubeSide, Frame.TexID, 0);
+		/*
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();
+		gluPerspective(90, 1, 1, 100);
+		glViewport(0, 0, Frame.Width, Frame.Height);
+		glMatrixMode(GL_MODELVIEW);*/
+
+		SetPerspectiveProjectionMatrix(90, 1, 1, 100);
+		
+		SetFrameViewport(frameName);
+		
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //IS A MUST!!!
+	}
+}
+
+
+
+void TSalmonRendererInterface::BeginDrawToDepthBufferGlobal(std::string& globalBufferName)
+{
+	SwitchToFrameBuffer(globalBufferName);
+	//SetGLLightProjectionAndView(ZeroVec3, GlobalShadowAreaHalfSize, 0);
+}
+
+
+void TSalmonRendererInterface::BeginDrawToDepthBufferLocal(std::string& localBufferName)
+{
+	SwitchToFrameBuffer(localBufferName);
+	//SetGLLightProjectionAndView(CamShift, GlobalShadowAreaHalfSize/3.0f, 1);
+}
+
+void TSalmonRendererInterface::EndDrawToDepthBuffer()
+{
+	SetPerspectiveFullScreenViewport();
+}
+
+
+} //namespace SE
+

src/Render/SalmonRender/SalmonRenderIos.cpp

@@ -0,0 +1,9 @@
+#include "include/Render/SalmonRender/SalmonRenderIos.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+} //namespace SE

src/Render/SalmonRender/SalmonRenderWindows.cpp

@@ -0,0 +1,335 @@
+#include "include/Render/SalmonRender/SalmonRenderWindows.h"
+
+#include "include/OpenGLExt/OpenGlExt.h"
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+//===================================================
+//================ RENDER ===========================
+//===================================================
+
+TSalmonRenderer::TSalmonRenderer() : 
+	ShadowClampValue(0.0f), 
+	FogBeginDistance(CONST_DEFAULT_FOG_BEGIN_DISTANCE), 
+	FogEndDistance(CONST_DEFAULT_FOG_END_DISTANCE), 
+	FogColor(CONST_DEFAULT_FOG_COLOR), 
+	LandToCalcCollision(NULL), 
+	IsCameraTransparentToLand(true)
+{ 
+
+}
+
+TSalmonRenderer::~TSalmonRenderer()
+{
+}
+
+
+
+bool TSalmonRenderer::BindOpenGLFunctions()
+{
+	char* extensionList = (char*)glGetString(GL_EXTENSIONS);
+	char* glVersion = (char*)glGetString(GL_VERSION);
+	bool ok = true;
+
+	*Console<<std::string("Render::OpenGL glVersion = ")+glVersion;
+	
+	//Requires OpenGL 2.0 or above
+	if (glVersion[0]>='2')
+	{
+		*Console<<"Render::OpenGL glVersion above 2.0 ok";
+
+		glActiveTexture = (PFNGLACTIVETEXTUREPROC) wglGetProcAddress("glActiveTexture");
+
+		glGenBuffers = (PFNGLGENBUFFERSPROC) wglGetProcAddress("glGenBuffers");
+		glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) wglGetProcAddress("glDeleteBuffers");
+		glBindBuffer = (PFNGLBINDBUFFERPROC) wglGetProcAddress("glBindBuffer");
+		glBufferData = (PFNGLBUFFERDATAPROC) wglGetProcAddress("glBufferData");
+		glBufferSubData = (PFNGLBUFFERSUBDATAPROC) wglGetProcAddress("glBufferSubData");
+		glMapBuffer = (PFNGLMAPBUFFERPROC) wglGetProcAddress("glMapBuffer");
+		glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) wglGetProcAddress("glUnmapBuffer");
+
+		glCreateProgram = (PFNGLCREATEPROGRAMPROC) wglGetProcAddress("glCreateProgram");
+		glDeleteProgram = (PFNGLDELETEPROGRAMPROC) wglGetProcAddress("glDeleteProgram");
+		glLinkProgram = (PFNGLLINKPROGRAMPROC) wglGetProcAddress("glLinkProgram");
+		glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) wglGetProcAddress("glValidateProgram");
+		glUseProgram = (PFNGLUSEPROGRAMPROC) wglGetProcAddress("glUseProgram");
+		glGetProgramiv = (PFNGLGETPROGRAMIVPROC) wglGetProcAddress("glGetProgramiv");
+		glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) wglGetProcAddress("glGetProgramInfoLog");
+		glCreateShader = (PFNGLCREATESHADERPROC) wglGetProcAddress("glCreateShader");
+
+ 
+		glDeleteShader = (PFNGLDELETESHADERPROC) wglGetProcAddress("glDeleteShader");
+		glShaderSource = (PFNGLSHADERSOURCEPROC) wglGetProcAddress("glShaderSource");
+		glCompileShader = (PFNGLCOMPILESHADERPROC) wglGetProcAddress("glCompileShader");
+		glAttachShader = (PFNGLATTACHSHADERPROC) wglGetProcAddress("glAttachShader");
+		glDetachShader = (PFNGLDETACHSHADERPROC) wglGetProcAddress("glDetachShader");
+		glGetShaderiv = (PFNGLGETSHADERIVPROC) wglGetProcAddress("glGetShaderiv");
+		glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) wglGetProcAddress("glGetShaderInfoLog");
+		glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) wglGetProcAddress("glGetAttribLocation");
+		glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) wglGetProcAddress("glVertexAttribPointer");
+		glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) wglGetProcAddress("glEnableVertexAttribArray");
+
+		glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) wglGetProcAddress("glDisableVertexAttribArray");
+		glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) wglGetProcAddress("glGetUniformLocation");
+		glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) wglGetProcAddress("glUniformMatrix3fv");
+		glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) wglGetProcAddress("glUniformMatrix4fv");
+		glUniform1i = (PFNGLUNIFORM1IPROC) wglGetProcAddress("glUniform1i");
+		glUniform1fv = (PFNGLUNIFORM1FVPROC) wglGetProcAddress("glUniform1fv");
+		glUniform2fv = (PFNGLUNIFORM2FVPROC) wglGetProcAddress("glUniform2fv");
+		glUniform3fv = (PFNGLUNIFORM3FVPROC) wglGetProcAddress("glUniform3fv");
+		glUniform4fv = (PFNGLUNIFORM4FVPROC) wglGetProcAddress("glUniform4fv");
+
+		glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) wglGetProcAddress("glVertexAttrib1f");
+		glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) wglGetProcAddress("glVertexAttrib2f");
+		glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) wglGetProcAddress("glVertexAttrib3f");
+		glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) wglGetProcAddress("glVertexAttrib4f");
+		glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) wglGetProcAddress("glVertexAttrib2fv");
+		glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) wglGetProcAddress("glVertexAttrib3fv");
+		glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) wglGetProcAddress("glVertexAttrib4fv");
+		glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) wglGetProcAddress("glGetActiveAttrib");
+		glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) wglGetProcAddress("glGetActiveUniform");
+		
+
+		if (glActiveTexture==NULL ||
+			glGenBuffers==NULL ||
+			glDeleteBuffers==NULL ||
+			glBindBuffer==NULL ||
+			glBufferData==NULL ||
+			glBufferSubData==NULL ||
+			glMapBuffer==NULL ||
+			glCreateProgram==NULL ||
+			glDeleteProgram==NULL ||
+			glLinkProgram==NULL ||
+			glValidateProgram==NULL ||
+			glUseProgram==NULL ||
+			glGetProgramiv==NULL ||
+			glGetProgramInfoLog==NULL ||
+			glCreateShader==NULL ||
+			glDeleteShader==NULL ||
+			glShaderSource==NULL ||
+			glCompileShader==NULL ||
+			glAttachShader==NULL ||
+			glDetachShader==NULL ||
+			glGetShaderiv==NULL ||
+			glGetShaderInfoLog==NULL ||
+			glGetAttribLocation==NULL ||
+			glVertexAttribPointer==NULL ||
+			glEnableVertexAttribArray==NULL ||
+			glDisableVertexAttribArray==NULL ||
+			glGetUniformLocation==NULL ||
+			glUniformMatrix3fv==NULL ||
+			glUniformMatrix4fv==NULL ||
+			glUniform1i==NULL ||
+			glUniform1fv==NULL ||
+			glUniform2fv==NULL ||
+			glUniform3fv==NULL ||
+			glUniform4fv==NULL ||
+			glEnableVertexAttribArray==NULL ||
+			glVertexAttrib1f==NULL ||
+			glVertexAttrib2f==NULL ||
+			glVertexAttrib3f==NULL ||
+			glVertexAttrib4f==NULL ||
+			glVertexAttrib2fv==NULL ||
+			glVertexAttrib3fv==NULL ||
+			glVertexAttrib4fv==NULL ||
+			glGetActiveAttrib==NULL ||
+			glGetActiveUniform==NULL)
+		{
+			*Console<<"Render::OpenGL Some 2.0 version proc not found - starting failed";
+			ok = false;
+		}
+
+
+	}
+
+	else
+	{
+		*Console<<"Render::OpenGL glVersion below 2.0 - starting failed";
+		ok = false;
+	}
+	
+	if (findString("GL_ARB_framebuffer_object",extensionList))
+	{
+		*Console<<"Render::OpenGL GL_ARB_framebuffer_object supported ok";
+
+		glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) wglGetProcAddress("glIsRenderbuffer");
+		glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbuffer");
+		glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffers");
+		glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffers");
+		glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorage");
+		glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) wglGetProcAddress("glGetRenderbufferParameteriv");
+		glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) wglGetProcAddress("glIsFramebuffer");
+		glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebuffer");
+		glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffers");
+		glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffers");
+		glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatus");
+		glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) wglGetProcAddress("glFramebufferTexture1D");
+		glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2D");
+		glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) wglGetProcAddress("glFramebufferTexture3D");
+		glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbuffer");
+		glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) wglGetProcAddress("glGetFramebufferAttachmentParameteriv");
+		glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) wglGetProcAddress("glBlitFramebuffer");
+		glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) wglGetProcAddress("glRenderbufferStorageMultisample");
+		glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) wglGetProcAddress("glGenerateMipmap");
+		glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) wglGetProcAddress("glFramebufferTextureLayer");
+
+		if (glIsRenderbuffer == NULL ||
+			glBindRenderbuffer == NULL ||
+			glDeleteRenderbuffers == NULL ||
+			glGenRenderbuffers == NULL ||
+			glRenderbufferStorage == NULL ||
+			glGetRenderbufferParameteriv == NULL ||
+			glIsFramebuffer == NULL ||
+			glBindFramebuffer == NULL ||
+			glDeleteFramebuffers == NULL ||
+			glGenFramebuffers == NULL ||
+			glCheckFramebufferStatus == NULL ||
+			glFramebufferTexture1D == NULL ||
+			glFramebufferTexture2D == NULL ||
+			glFramebufferTexture3D == NULL ||
+			glFramebufferRenderbuffer == NULL ||
+			glGetFramebufferAttachmentParameteriv == NULL ||
+			glBlitFramebuffer == NULL ||
+			glRenderbufferStorageMultisample == NULL ||
+			glGenerateMipmap == NULL ||
+			glFramebufferTextureLayer == NULL)
+		{
+			*Console<<"Render::OpenGL Some GL_ARB_framebuffer_object proc not found - starting failed";
+			ok = false;
+		}
+
+
+	}
+	else
+	{
+		*Console<<"Render::OpenGL GL_ARB_framebuffer_object not supported - starting failed";
+		ok = false;
+	}
+
+	if (findString("GL_ARB_uniform_buffer_object",extensionList))
+	{
+
+		glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) wglGetProcAddress("glGetUniformIndices");
+		glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) wglGetProcAddress("glGetActiveUniformsiv");
+		glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) wglGetProcAddress("glGetActiveUniformName");
+		glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) wglGetProcAddress("glGetUniformBlockIndex");
+		glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) wglGetProcAddress("glGetActiveUniformBlockiv");
+		glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) wglGetProcAddress("glGetActiveUniformBlockName");
+		glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) wglGetProcAddress("glUniformBlockBinding");
+		glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) wglGetProcAddress("glBindBufferBase");
+
+		if (glGetUniformIndices == NULL ||
+			glGetActiveUniformsiv == NULL ||
+			glGetActiveUniformName == NULL ||
+			glGetUniformBlockIndex == NULL ||
+			glGetActiveUniformBlockiv == NULL ||
+			glGetActiveUniformBlockName == NULL ||
+			glUniformBlockBinding == NULL ||
+			glBindBufferBase == NULL)
+		{
+			*Console<<"Render::OpenGL some GL_ARB_uniform_buffer_object proc not found - starting failed";
+			ok = false;
+		}
+	
+			
+		*Console<<"Render::OpenGL GL_ARB_uniform_buffer_object supported ok";
+	}
+	else
+	{
+		*Console<<"Render::OpenGL GL_ARB_uniform_buffer_object not supported - starting failed";
+		ok = false;
+	}
+
+	return ok;
+}
+
+
+
+void TSalmonRenderer::DrawQuad(const T2DQuad& quad)
+{
+	const float CONST_DEFAULT_NORM_VEC[3] = { 0.0f, 0.0f, 1.0f};
+
+	glBegin(GL_QUADS);
+		VertexAttrib3fv(CONST_STRING_NORMAL_ATTRIB, CONST_DEFAULT_NORM_VEC);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[0].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[0].v);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[1].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[1].v);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[3].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[3].v);
+		VertexAttrib2fv(CONST_STRING_TEXCOORD_ATTRIB, quad.TextureCoord[2].v);
+		VertexAttrib3fv(CONST_STRING_POSITION_ATTRIB, quad.VertexCoord[2].v);
+	glEnd();
+}
+
+
+
+void TSalmonRenderer::SetLandToCalcCollision(TSimpleLandClass* landToCalcCollision)
+{
+	IsCameraTransparentToLand = false;
+	LandToCalcCollision = landToCalcCollision;
+}
+
+
+float TSalmonRenderer::GetShadowClampValue() 
+{ 
+	return ShadowClampValue; 
+}
+
+void TSalmonRenderer::SetShadowClampValue(float shadowClampValue)
+{
+	ShadowClampValue = shadowClampValue;
+
+	if (ShadowClampValue < 0.0f)
+		ShadowClampValue = 0.0f;
+
+	if (ShadowClampValue > 1.0f)
+		ShadowClampValue = 1.0f;
+
+	RenderUniform1f(CONST_STRING_SHADOWCLAMPVALUE_UNIFORM, ShadowClampValue);
+}
+
+
+float TSalmonRenderer::GetFogBeginDistance()
+{
+	return FogBeginDistance;
+}
+
+float TSalmonRenderer::GetFogEndDistance()
+{
+	return FogEndDistance;
+}
+
+vec4 TSalmonRenderer::GetFogColor()
+{
+	return FogColor;
+}
+	
+
+
+
+void TSalmonRenderer::DrawTriangleList(const TTriangleList& triangleList)
+{
+	BOOST_FOREACH(auto& i, triangleList.Data.Vec2CoordArr)
+	{
+		glBindBuffer(GL_ARRAY_BUFFER, triangleList.VertBufferArr[i.first]->Buffer);
+		VertexAttribPointer2fv(i.first, 0, NULL);
+	}
+	
+	BOOST_FOREACH(auto& i, triangleList.Data.Vec3CoordArr)
+	{
+		glBindBuffer(GL_ARRAY_BUFFER, triangleList.VertBufferArr[i.first]->Buffer);
+		VertexAttribPointer3fv(i.first, 0, NULL);
+	}
+
+	if (!triangleList.Data.Vec3CoordArr.empty())
+	{
+		glDrawArrays(GL_TRIANGLES,0,triangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB].size());
+	}
+
+}
+
+} //namespace SE

src/SalmonEngineAndroid.cpp

@@ -0,0 +1,82 @@
+#include "include/SalmonEngineAndroid.h"
+
+#include "include/Utils/Utils.h"
+
+namespace SE
+{
+
+void TApplication::OuterInit(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+	OuterDeinit();
+    
+    Console = new TJavaConsole;
+	
+	*Console<<std::string("Console successfully started!!!");
+	
+    ResourceManager = new TResourceManager;
+
+	Renderer = new TSalmonRendererAndroid;
+
+	ResourceManager->ScriptManager.BindBasicFunctions();
+
+	InnerInit();
+	
+	Renderer->InitOpenGL(screenWidth, screenHeight, matrixWidth, matrixHeight);
+	CheckGlError();
+}
+
+
+void TApplication::OuterDeinit()
+{
+
+	if (Console != NULL)
+	{
+	*Console<<"OuterDeinit";
+    }
+	
+	InnerDeinit();
+
+	if (ResourceManager != NULL)
+    {
+	   delete ResourceManager;
+	   ResourceManager = NULL;
+    }
+	
+	if (Console != NULL)
+	{
+	*Console<<"Resource manager deleted, deleting salmon render";
+	}
+	
+    if (Renderer != NULL)
+    {
+	   delete Renderer;
+	   Renderer = NULL;
+    }
+	if (Console != NULL)
+	{
+	*Console<<"salmon render deleted";
+	}
+    
+    
+    
+    if (Console != NULL)
+    {
+	   delete Console;
+	   Console = NULL;
+    }
+	
+}
+
+
+void TApplication::OuterDraw()
+{
+	InnerDraw();
+}
+
+void TApplication::OuterUpdate(cardinal timer)
+{
+	InnerUpdate(timer);
+}
+
+
+} //namespace SE

src/SalmonEngineInterface.cpp

@@ -0,0 +1,73 @@
+#include "include/SalmonEngineInterface.h"
+namespace SE
+{
+
+#ifdef TARGET_ANDROID
+TJavaConsole* Console;
+TSalmonRendererAndroid* Renderer;
+#endif
+
+
+#ifdef TARGET_WIN32
+TFileConsole* Console;
+TSalmonRenderer* Renderer;
+#endif
+
+#ifdef TARGET_IOS
+TIosConsole* Console;
+TSalmonRendererIos* Renderer;
+#endif
+
+TResourceManager* ResourceManager;
+
+
+TApplicationAncestor::TApplicationAncestor()
+{
+
+}
+
+void TApplicationAncestor::OuterDeinit()
+{
+    InnerDeinit();
+}
+
+
+void TApplicationAncestor::OuterDraw()
+{
+	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+	glActiveTexture(GL_TEXTURE0);
+	RenderUniform1i("Texture", 0);
+	RenderUniform1f("Transparency", 1.f);
+	
+	InnerDraw();
+
+	glDisable(GL_DEPTH_TEST);
+	Renderer->PushShader("DefaultShader");
+	
+	if (IsConsoleOut) 
+	{
+		Console->Draw();
+	}
+	
+	Renderer->PopShader();
+	glEnable(GL_DEPTH_TEST);
+}
+
+void TApplicationAncestor::OuterUpdate(cardinal timer)
+{
+	ResourceManager->SoundManager.Update(timer);
+
+	InnerUpdate(timer);
+
+	CheckGlError();
+}
+
+void TApplicationAncestor::OuterOnMove(vec2 shift)
+{
+	InnerOnMove(shift);
+}
+
+
+} //namespace SE

src/SalmonEngineIos.cpp

@@ -0,0 +1,83 @@
+#include "include/SalmonEngineIos.h"
+
+#include "include/Utils/Utils.h"
+
+
+namespace SE
+{
+
+void TApplication::OuterInit(int screenWidth, int screenHeight, float matrixWidth, float matrixHeight)
+{
+	OuterDeinit();
+    
+    Console = new TIosConsole;
+	
+	*Console<<std::string("Console successfully started!!!");
+	
+    ResourceManager = new TResourceManager;
+
+	Renderer = new TSalmonRendererIos;
+
+	ResourceManager->ScriptManager.BindBasicFunctions();
+
+	InnerInit();
+	
+	Renderer->InitOpenGL(screenWidth, screenHeight, matrixWidth, matrixHeight);
+	CheckGlError();
+}
+
+
+void TApplication::OuterDeinit()
+{
+	
+	if (Console != NULL)
+	{
+	*Console<<"OuterDeinit";
+    }
+	
+	InnerDeinit();
+
+	if (ResourceManager != NULL)
+    {
+	   delete ResourceManager;
+	   ResourceManager = NULL;
+    }
+	
+	if (Console != NULL)
+	{
+	*Console<<"Resource manager deleted, deleting salmon render";
+	}
+	
+    if (Renderer != NULL)
+    {
+	   delete Renderer;
+	   Renderer = NULL;
+    }
+	if (Console != NULL)
+	{
+        *Console<<"salmon render deleted";
+	}
+    
+    
+    
+    if (Console != NULL)
+    {
+	   delete Console;
+	   Console = NULL;
+    }
+	
+}
+
+
+void TApplication::OuterDraw()
+{
+	InnerDraw();
+}
+
+void TApplication::OuterUpdate(cardinal timer)
+{
+	InnerUpdate(timer);
+}
+
+
+} //namespace SE

src/SalmonEngineWindows.cpp

@@ -0,0 +1,401 @@
+
+#include "include/Utils/Utils.h"
+#include "include/SalmonEngineWindows.h"
+
+
+namespace SE
+{
+
+//==============================================================
+//========= GLOBAL VARIABLES - REMEMBER THIS LIST!!! ===========
+//==============================================================
+
+HGLRC hRC;		//Render context
+HWND Hwnd;		//Main window handle
+HDC hDC;		//Device context
+
+//==============================================================
+//=============== GLOBAL VARS ENDS =============================
+//==============================================================
+
+//There might be anything
+const char CONST_WINDOW_CLASS_NAME[] = "TSalmonEngineForm";
+
+const cardinal CONST_TIMER_INTERVAL = 10;
+
+//To calculate when to call Update
+cardinal NewTickCount;
+cardinal LastTickCount;
+
+//User application
+TApplication* App = NULL;
+
+
+
+void TApplication::OnKeyPress(cardinal key)
+{
+	if (IsConsoleOut)
+	{
+		
+		if (key == 96 || key == 126 /*|| key == 184 || key == 168*/) //~, 184 and 168 is russian e
+		{
+			IsConsoleOut = false;
+		}
+		else if (key == 8) //Backspace
+		{
+			if (Console->ConsoleInput.size() > 0 && Console->ConsoleCursor > 0)
+			{
+				Console->ConsoleInput.erase(Console->ConsoleInput.begin() + Console->ConsoleCursor-1);
+				Console->ConsoleCursor--;
+			}
+		}
+		else if (key == 13|| key == 10) //Enter
+		{
+			ResourceManager->ScriptManager.RunScript(Console->ConsoleInput);
+
+			Console->InputHistory.push_back(Console->ConsoleInput);
+
+			Console->InputHistoryCursor = Console->InputHistory.size();
+
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = 0;
+		}
+		else if (key >= 32 && key <= 255) //ASCII
+		{
+			Console->ConsoleInput.insert(Console->ConsoleInput.begin()+Console->ConsoleCursor, static_cast<char>(key));
+			Console->ConsoleCursor++;
+		}
+		else if (key > 0x100) //VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT
+		{
+			cardinal realKey = key - 0x100;
+
+			if (realKey == VK_UP)
+			{
+				if (Console->InputHistoryCursor > 0)
+				{
+					Console->InputHistoryCursor--;
+					Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+					Console->ConsoleCursor = Console->ConsoleInput.size();
+				}
+			}
+			if (realKey == VK_DOWN)
+			{
+				if ( Console->InputHistoryCursor+1 < Console->InputHistory.size())
+				{
+					Console->InputHistoryCursor++;
+					Console->ConsoleInput = Console->InputHistory[Console->InputHistoryCursor];
+					Console->ConsoleCursor = Console->ConsoleInput.size();
+				}
+			}
+			if (realKey == VK_LEFT)
+			{
+				if (Console->ConsoleCursor > 0)
+				{
+					Console->ConsoleCursor--;
+				}
+			}
+			if (realKey == VK_RIGHT)
+			{
+				if (Console->ConsoleCursor < Console->ConsoleInput.size())
+				{
+					Console->ConsoleCursor++;
+				}
+			}
+
+		}
+		else
+		{
+			*Console<<"Key is "+tostr(key)+endl;
+		}
+
+	}
+	else
+	{
+		if (key == 96 || key == 126 /*|| key == 184 || key == 168*/) //~, 184 and 168 is russian e
+		{
+			IsConsoleOut = true;
+			Console->ConsoleInput = "";
+			Console->ConsoleCursor = Console->ConsoleInput.size();
+		}
+	}
+}
+
+
+void DrawScene()
+{
+	App->OuterDraw();
+    SwapBuffers(hDC);
+}
+
+void ProcessTickCount()
+{
+
+	App->UpdateQuick();
+	NewTickCount = GetTickCount();
+	if (NewTickCount - LastTickCount > CONST_TIMER_INTERVAL)
+	{
+		LastTickCount = NewTickCount;
+		App->OuterUpdate(CONST_TIMER_INTERVAL);
+	}
+
+}
+
+LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{ 
+    static PAINTSTRUCT ps;
+
+	TMouseState mouseState;
+
+    switch(uMsg) 
+	{
+	case WM_CLOSE:
+		Hwnd = 0; //HACK to force window to close
+		PostQuitMessage(0);
+		//Xperimental
+		return DefWindowProc(hWnd, uMsg, wParam, lParam); 
+
+		break;
+	case WM_PAINT: 
+		DrawScene();
+		BeginPaint(hWnd, &ps);
+		EndPaint(hWnd, &ps);
+
+		ProcessTickCount();
+		break;
+	case WM_SIZE:
+		
+		PostMessage(hWnd, WM_PAINT, 0, 0);
+		break;
+	case WM_CHAR:
+		App->OnKeyPress(wParam);
+		/*
+		switch (wParam) 
+		{
+		case 27:
+				PostQuitMessage(0);
+				Hwnd = 0;
+				
+				//Xperimental
+				return DefWindowProc(hWnd, uMsg, wParam, lParam); 
+
+				break;
+		//... Will add more code later
+		}*/
+		break;
+
+	case WM_MOUSEMOVE:
+		mouseState.X = (lParam << 16) >> 16;
+		mouseState.Y = lParam >> 16;
+		mouseState.LeftButtonPressed = (wParam & MK_LBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_MBUTTON);
+		mouseState.RightButtonPressed = (wParam & MK_RBUTTON);
+
+		App->OnMouseMove(mouseState);
+		break;
+
+	case WM_LBUTTONDOWN:
+	case WM_RBUTTONDOWN:
+		mouseState.X = (lParam << 16) >> 16;
+		mouseState.Y = lParam >> 16;
+		mouseState.LeftButtonPressed = (wParam & MK_LBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_MBUTTON);
+		mouseState.RightButtonPressed = (wParam & MK_RBUTTON);
+
+		App->OnMouseDown(mouseState);
+		break;
+	case WM_LBUTTONUP:
+	case WM_RBUTTONUP:
+		mouseState.X = (lParam << 16) >> 16;
+		mouseState.Y = lParam >> 16;
+		mouseState.LeftButtonPressed = (wParam & MK_LBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_MBUTTON);
+		mouseState.MiddleButtonPressed = (wParam & MK_RBUTTON);
+
+		App->OnMouseUp(mouseState);
+		break;
+	
+	case WM_MOUSEWHEEL:
+		App->OnMouseWheel(wParam >> 16);
+		break;
+    }
+
+    return DefWindowProc(hWnd, uMsg, wParam, lParam); 
+} 
+
+bool CreateOpenGLWindow(const char* title, int x, int y, int width, int height,HWND& hWnd, HDC& hDC, HGLRC& hRC)
+{
+    int pf;
+    WNDCLASS wc;
+    PIXELFORMATDESCRIPTOR pfd;
+    static HINSTANCE hInstance = 0;
+
+    if (!hInstance) 
+	{
+		hInstance = GetModuleHandle(NULL);
+		wc.style = CS_OWNDC;
+		wc.lpfnWndProc = (WNDPROC)WindowProc;
+		wc.cbClsExtra = 0;
+		wc.cbWndExtra = 0;
+		wc.hInstance = hInstance;
+		wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
+		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+		wc.hbrBackground = NULL;
+		wc.lpszMenuName  = NULL;
+		wc.lpszClassName = CONST_WINDOW_CLASS_NAME;
+
+		if (!RegisterClass(&wc)) 
+		{
+			return NULL;
+		}
+    }
+
+	RECT r;
+	r.left = x;
+	r.right = x + width;
+	r.top = y;
+	r.bottom = y + height;
+	
+	DWORD windowStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; 
+
+	AdjustWindowRect(&r, windowStyle, false);
+	
+	hWnd = CreateWindow(CONST_WINDOW_CLASS_NAME, title, windowStyle, 0, 0, r.right-r.left, r.bottom-r.top, NULL, NULL, hInstance, NULL);
+
+    if (hWnd == NULL) 
+	{
+		return false;
+    }
+
+    hDC = GetDC(hWnd);
+
+    memset(&pfd, 0, sizeof(pfd));
+    pfd.nSize = sizeof(pfd);
+    pfd.nVersion = 1;
+    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+    pfd.iPixelType = PFD_TYPE_RGBA;
+    pfd.cColorBits = 32;
+
+    pf = ChoosePixelFormat(hDC, &pfd);
+    if (pf == 0) 
+	{
+		return false;
+    } 
+ 
+    if (SetPixelFormat(hDC, pf, &pfd) == FALSE) 
+	{
+		return false;
+    } 
+
+    hRC = wglCreateContext( hDC );
+	wglMakeCurrent( hDC, hRC );
+
+    return true;
+}    
+
+int MainLoop(TApplication& application)
+{
+    MSG msg;
+
+	//Here console log is not created so we can not use ErrorCommon
+	try
+	{
+		Console = new TFileConsole(application.GetLogFilename());
+	}
+	catch(...)
+	{
+		exit(1);
+	}
+
+	//Here console log is already created
+	try
+	{
+
+	*Console<<"Log started";
+    
+	if (!CreateOpenGLWindow(application.WindowName.c_str(), application.X, application.Y, application.Width, application.Height,Hwnd,hDC,hRC))
+	{
+		*Console<<"Unable to create OpenGL Window!";
+		exit(1);
+	}
+
+	*Console<<"OpenGL Window created";
+
+	
+		if (App != NULL)
+			throw ErrorCommon();
+
+		App = &application;
+
+		Renderer = new TSalmonRenderer;
+		ResourceManager = new TResourceManager;
+
+		int width;
+		int height;
+
+		GetWindowWidthHeight(width, height);
+
+
+		if (Renderer->BindOpenGLFunctions())
+		{
+
+			App->OuterInit(width, height, static_cast<float>(width), static_cast<float>(height));
+	
+			ShowWindow(Hwnd, SW_SHOW);
+			UpdateWindow(Hwnd);
+
+			NewTickCount = GetTickCount();
+			LastTickCount = NewTickCount;
+
+			bool StayIn = true;
+
+			while (StayIn) 
+			{
+				while(PeekMessage(&msg, Hwnd, 0, 0, PM_NOREMOVE)) 
+				{
+					if(GetMessage(&msg, Hwnd, 0, 0)) 
+					{
+						TranslateMessage(&msg);
+						DispatchMessage(&msg);
+					} 
+					else
+					{
+						StayIn = false;
+					}
+				}
+				DrawScene();
+
+				ProcessTickCount();
+			}
+
+		}
+
+		*Console<<"Program prepares to quit";
+
+		App->OuterDeinit();
+
+		delete ResourceManager;
+		delete Renderer;
+
+
+		wglMakeCurrent(NULL, NULL);
+		ReleaseDC(Hwnd,hDC);
+		wglDeleteContext(hRC);
+		DestroyWindow(Hwnd);
+
+	}
+	catch(...)
+	{
+		//... let the ErrorTypes.h do the buisness
+	}
+
+
+	delete Console;
+
+	
+    return 0;
+}
+
+
+
+} //namespace SE
+

src/ScriptManager/ScriptManager.cpp

@@ -0,0 +1,206 @@
+#include "include/Engine.h"
+#include "include/ScriptManager/ScriptManager.h"
+
+
+namespace SE
+{
+
+std::vector<TFunctionBinderInterface*> TFunctionBinderInterface::BinderList;
+
+
+TScriptManager::TScriptManager()
+{
+	SquirrelVM::Init();
+
+	virtualMachine = SquirrelVM::GetVMPtr();
+
+	//SqPlus::RegisterGlobal(virtualMachine, SQ_Print, _SC("Print"));
+	//SqPlus::RegisterGlobal(virtualMachine, SQ_Print, _SC("p"));
+
+	//boost::function<void()> f = xxx;
+
+	/*
+	SqPlus::RegisterGlobal(virtualMachine, ResourceManager->GUIManager, &TGUIManager::PrintWidgetList, _SC("PrintWidgetList"));
+	//SqPlus::RegisterGlobal(virtualMachine, SQ_PrintWidgetList, _SC("pwl"));
+	//SqPlus::RegisterGlobal(virtualMachine, Tm<boost::function<void()> >(f), &Tm<boost::function<void()> >::operator(), _SC("pwl"));
+	RegisterFunc(ResourceManager->GUIManager, &TGUIManager::PrintWidgetList, "");
+	*/
+
+	/*
+	AddFunction("pwl", 
+		TScriptInfo("PrintWidgetList", "Print out list of widgets registered in system", "Print out list of widgets registered in system"),
+		ResourceManager->GUIManager,
+		&TGUIManager::PrintWidgetList);*/
+
+	/*
+	AddFuncDescription("pwl", TScriptInfo("PrintWidgetList", "Print out list of widgets registered in system", "Print out list of widgets registered in system"));
+	SqPlus::RegisterGlobal(virtualMachine, ResourceManager->GUIManager, &TGUIManager::PrintWidgetList, _SC("PrintWidgetList"));
+	SqPlus::RegisterGlobal(virtualMachine, ResourceManager->GUIManager, &TGUIManager::PrintWidgetList, _SC("pwl"));
+
+	SqPlus::RegisterGlobal(virtualMachine, SQ_MoveWidget, _SC("MoveWidget"));
+	SqPlus::RegisterGlobal(virtualMachine, SQ_MoveWidget, _SC("mw"));
+
+	SqPlus::RegisterGlobal(virtualMachine, SQ_MoveWidgetTransformTaskTest, _SC("MoveWidgetTransformTaskTest"));
+	SqPlus::RegisterGlobal(virtualMachine, SQ_MoveWidgetTransformTaskTest, _SC("mwttt"));
+
+	SqPlus::RegisterGlobal(virtualMachine, SQ_PrintTextureList, _SC("PrintTextureList"));
+	SqPlus::RegisterGlobal(virtualMachine, SQ_PrintTextureList, _SC("ptl"));
+
+	SqPlus::RegisterGlobal(virtualMachine, SQ_PrintAnimationList, _SC("PrintAnimationList"));
+	SqPlus::RegisterGlobal(virtualMachine, SQ_PrintAnimationList, _SC("pal"));
+	*/
+
+	
+	*Console<<"Script manager ready";
+}
+
+
+TScriptManager::~TScriptManager()
+{
+	*Console<<"Script manager shutdown";
+	SquirrelVM::Shutdown();
+}
+
+void TScriptManager::RunScript(const std::string& scriptCode)
+{
+	try
+	{
+		SquirrelObject m = SquirrelVM::CompileBuffer(_T(scriptCode.c_str()));
+
+		SquirrelVM::RunScript(m);
+	}
+	catch (SquirrelError)
+	{
+		*Console<<"Script failed to run";
+	}
+	
+}
+
+
+void TScriptManager::BindBasicFunctions()
+{
+	//Hack =D
+	static bool alreadyBind = false;
+	
+	if (!alreadyBind)
+	{
+	*Console<<"Bind basic functions";
+
+	AddFunction("p", TScriptInfo("Print"), SQ_Print);
+
+	AddFunction("help", TScriptInfo("Help"), *this, &TScriptManager::PrintRegisteredFunctionList);
+
+	AddFunction("man", TScriptInfo("Manual"), *this, &TScriptManager::PrintFunctionInfo);
+
+	std::vector<TFunctionBinderInterface*>::iterator i;
+
+	for (i = TFunctionBinderInterface::BinderList.begin(); i != TFunctionBinderInterface::BinderList.end(); ++i)
+	{
+
+		(*i)->BindFunctions();
+	}
+
+	alreadyBind = true;
+	}
+
+
+
+	
+}
+
+
+void TScriptManager::AddFuncDescription(const std::string& shortName, TScriptInfo scriptInfo)
+{
+	if (FuncInfoMap.count(shortName) > 0)
+	{
+		//If this description is already exists
+		scriptInfo.Registered = FuncInfoMap[shortName].Registered;
+	}
+	
+	FuncInfoMap[shortName] = scriptInfo;
+
+
+}
+
+
+void TScriptManager::BindFunctionsFromObject(TFunctionBinderInterface* binderObject)
+{
+	binderObject->BindFunctions();
+}
+
+
+void TScriptManager::PrintRegisteredFunctionList()
+{
+	std::map<std::string, TScriptInfo>::iterator i;
+
+	Console->PrintImmediate("========== Console function list ===========");
+
+	for (i = FuncInfoMap.begin(); i != FuncInfoMap.end(); ++i)
+	{
+		if (i->second.Registered)
+		{
+			Console->PrintImmediate(i->first + " | " + i->second.ShortDescription);
+		}
+	}
+}
+
+void TScriptManager::PrintFunctionInfo(const std::string& funcName)
+{
+	if (FuncInfoMap.count(funcName) > 0 && FuncInfoMap[funcName].Registered)
+	{
+		Console->PrintImmediate( funcName + " | " + FuncInfoMap[funcName].LongName + " | " + FuncInfoMap[funcName].Description);
+	}
+}
+
+void TScriptManager::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("FunctionInfoList"))
+	{
+		std::string shortName = v.second.get<std::string>("ShortName");
+		std::string longName = v.second.get<std::string>("LongName");
+		std::string shortDescription = v.second.get<std::string>("ShortDescription");
+		std::string description = v.second.get<std::string>("Description");
+		
+		AddFuncDescription(shortName, TScriptInfo(longName, shortDescription, description));
+	}
+}
+
+
+//=============================================
+//============= Typical commands ==============
+//=============================================
+
+void SQ_Print(const SQChar *inString)
+{
+	Console->PrintImmediate(std::string(inString));
+}
+
+/*
+void SQ_PrintWidgetList()
+{
+	ResourceManager->GUIManager.PrintWidgetList();
+}
+
+void SQ_MoveWidget(const SQChar *widgetName, float x, float y)
+{
+	ResourceManager->GUIManager.MoveWidget(std::string(widgetName), vec2(x,y));
+}
+
+void SQ_MoveWidgetTransformTaskTest(const SQChar *groupName, float x, float y, cardinal totalTime)
+{
+	ResourceManager->GUIManager.AddWidgetTransformTask(TWidgetTransformTask(std::string(groupName), vec2(x,y), totalTime, 0, TWidgetTransformTask::MS_SQRT));
+}
+
+
+void SQ_PrintTextureList()
+{
+	ResourceManager->TexList.PrintTextureList();
+}
+
+void SQ_PrintAnimationList()
+{
+	ResourceManager->HalibutAnimationManager.PrintAnimationList();
+}*/
+
+} //namespace SE

src/ShaderManager/ShaderManager.cpp

@@ -0,0 +1,405 @@
+#include "include/ShaderManager/ShaderManager.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+namespace SE
+{
+
+//===================================================
+//============== SHADER RESOURCE ====================
+//===================================================
+
+
+
+TShaderResource::TShaderResource()
+	: ShaderProgram(0)
+{
+}
+
+TShaderResource::~TShaderResource() 
+{ 
+	
+	*Console<<"ResourceManager::ShaderManager::Shader deleting";
+	FreeShader();
+	
+}
+
+bool TShaderResource::CompileShader(boost::shared_array<char> vertexCode, boost::shared_array<char> fragmentCode)
+{
+
+	FreeShader();
+
+	const int CONST_INFOLOG_LENGTH = 256;
+
+	char infoLog[CONST_INFOLOG_LENGTH];
+	int infoLogLength;
+
+	int vertexShaderCompiled;
+	int fragmentShaderCompiled;
+	int programLinked;
+
+	cardinal vertexShader;
+	cardinal fragmentShader;
+
+	int vertexCodeLength = strlen(vertexCode.get());
+	int fragmentCodeLength = strlen(fragmentCode.get());
+
+	const char* vc = &vertexCode[0];
+	const char* fc = &fragmentCode[0];
+
+	vertexShader = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(vertexShader, 1, &(vc), &vertexCodeLength);
+
+	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(fragmentShader, 1, &(fc), &fragmentCodeLength);
+	
+	glCompileShader(vertexShader);
+	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vertexShaderCompiled);
+	glGetShaderInfoLog(vertexShader, CONST_INFOLOG_LENGTH, &infoLogLength, infoLog);
+	*Console<<"ResourceManager::ShaderManager::Shader "+std::string(infoLog);
+
+	glCompileShader(fragmentShader);
+	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fragmentShaderCompiled);
+	glGetShaderInfoLog(fragmentShader, CONST_INFOLOG_LENGTH, &infoLogLength, infoLog);
+	*Console<<"ResourceManager::ShaderManager::Shader " + std::string(infoLog);
+
+	if (!vertexShaderCompiled || !fragmentShaderCompiled)
+		return false;
+
+	ShaderProgram = glCreateProgram();
+	*Console<<"Shader program is - " + tostr(ShaderProgram);
+	glAttachShader(ShaderProgram, vertexShader);
+	glAttachShader(ShaderProgram, fragmentShader);
+
+	glLinkProgram(ShaderProgram);
+
+	glDeleteShader(vertexShader);
+	glDeleteShader(fragmentShader);
+
+	glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &programLinked);
+	glGetProgramInfoLog(ShaderProgram, CONST_INFOLOG_LENGTH, &infoLogLength, infoLog);
+
+	*Console<<"ResourceManager::ShaderManager::Shader "+std::string(infoLog);
+
+	if (!programLinked)
+	{
+		ShaderProgram = 0;
+		return false;
+	}
+	
+	
+	int dummySize;			//Dummy
+	int dummyLen;			//Dummy
+	cardinal dummyType;		//Dummy
+
+	//================= Parsing all uniforms ================
+
+	int activeUniforms;
+
+	const int CONST_UNIFORM_NAME_LENGTH = 256;
+	char uniformName[CONST_UNIFORM_NAME_LENGTH];
+
+	glGetProgramiv(ShaderProgram, GL_ACTIVE_UNIFORMS, &activeUniforms);
+
+	for (int i = 0; i < activeUniforms; i++)
+	{
+		glGetActiveUniform(ShaderProgram, i, CONST_UNIFORM_NAME_LENGTH, &dummyLen, &dummySize, &dummyType, uniformName);
+		UniformList[uniformName] = glGetUniformLocation(ShaderProgram, uniformName);
+	}
+
+	//================= Parsing all attributes ================
+	int activeAttribs;
+
+	const int CONST_ATTRIB_NAME_LENGTH = 256;
+	char attribName[CONST_ATTRIB_NAME_LENGTH];
+
+	glGetProgramiv(ShaderProgram, GL_ACTIVE_ATTRIBUTES, &activeAttribs);
+
+	for (int i = 0; i < activeAttribs; i++)
+	{
+		glGetActiveAttrib(ShaderProgram, i, CONST_ATTRIB_NAME_LENGTH, &dummyLen, &dummySize, &dummyType, attribName);
+		AttribList[attribName] = glGetAttribLocation(ShaderProgram, attribName);
+	}
+
+	return true;
+}
+
+void TShaderResource::FreeShader()
+{
+
+	if (ShaderProgram != 0)
+	{
+#ifdef TARGET_ANDROID
+		if (glIsProgram(ShaderProgram))
+		{
+			glDeleteProgram(ShaderProgram);
+		}
+#else
+		glDeleteProgram(ShaderProgram);
+#endif
+		ShaderProgram = 0;
+	}
+
+	UniformList.clear();
+	AttribList.clear();
+}
+
+int TShaderResource::GetAttribIndex(const std::string& attribName)
+{
+	if (AttribList.count(attribName) > 0)
+		return AttribList[attribName];
+	else
+		return -1;
+}
+
+int TShaderResource::GetUniformIndex(const std::string& uniformName)
+{
+	if (UniformList.count(uniformName) > 0)
+		return UniformList[uniformName];
+	else
+		return -1;
+}
+
+
+
+
+//===================================================
+//=============== SHADER MANAGER ====================
+//===================================================
+
+
+TShaderManager::~TShaderManager()
+{
+	Clear();
+	*Console<<"ResourceManager::ShaderManager deleting"; 
+}
+
+std::shared_ptr<TShaderResource> TShaderManager::GetCurrentShader() 
+{
+	if (ShaderNameStack.size() == 0)
+	{
+		throw ErrorToLog("GetCurrentShader: Shader is not selected!");
+	}
+	
+	return ShaderList[ShaderNameStack.top()]; 
+}
+
+void TShaderManager::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Shaders"))
+	{
+		std::string shaderName = v.second.get<std::string>("Name");
+		std::string vertexFileName = v.second.get<std::string>("VertexFileName");
+		std::string fragmentFileName = v.second.get<std::string>("FragmentFileName");
+
+		AddShader(shaderName, vertexFileName, fragmentFileName);
+
+	}
+}
+
+bool TShaderManager::AddShader(const std::string& shaderName, const std::string& vertexFileName, const std::string& fragmentFileName)
+{
+
+	std::string pathToResources = ResourceManager->PathToResources;
+
+	if (ShaderList.count(shaderName) > 0)
+	{
+		*Console<<"ResourceManager::ShaderManager ERROR shader already exists: "+shaderName;
+		return false;
+	}
+
+	*Console<<"Prepare to add shader "+shaderName;
+	cardinal fSize;
+	boost::shared_array<char> fPointer;
+	boost::shared_array<char> vertexCode;
+	boost::shared_array<char> fragmentCode;
+
+	fPointer = CreateMemFromFile<char>(pathToResources + vertexFileName, fSize);
+	
+	vertexCode = boost::shared_array<char>(new char [fSize + 1]);
+
+	memcpy(vertexCode.get(), fPointer.get(), fSize);
+
+	vertexCode[fSize] = 0;
+	
+	fPointer = CreateMemFromFile<char>(pathToResources + fragmentFileName, fSize);
+
+	fragmentCode = boost::shared_array<char>(new char [fSize + 1]);
+	
+	memcpy(fragmentCode.get(), fPointer.get(), fSize);
+	
+	fragmentCode[fSize] = 0;
+
+	std::shared_ptr<TShaderResource> shaderResource(new TShaderResource);
+
+	ShaderList[shaderName] = shaderResource;
+	
+	if (!ShaderList[shaderName]->CompileShader(vertexCode, fragmentCode))
+	{
+		*Console<<"ResourceManager::ShaderManager ERROR shader could not be compiled or linked: "+shaderName;
+		return false;
+	}
+
+	*Console<<"ResourceManager::ShaderManager shader loaded: "+shaderName;
+
+	return true;
+}
+
+void TShaderManager::Clear() 
+{
+	glUseProgram(0);
+	ShaderList.clear();
+	*Console<<"ResourceManager::ShaderManager cleared";
+}
+
+
+void TShaderManager::PushShader(const std::string& shaderName)
+{
+
+	if (ShaderList.count(shaderName) == 0) 
+		throw ErrorShaderNotExists(shaderName);
+
+	if (ShaderNameStack.size() >= CONST_MAX_STACK_SIZE)
+		throw ErrorShaderStackOverflow();
+
+	
+	if (ShaderNameStack.size() == 0 || ShaderNameStack.top() != shaderName)
+	{
+		glUseProgram(ShaderList[shaderName]->ShaderProgram);
+	}
+
+	ShaderNameStack.push(shaderName);
+}
+
+
+void TShaderManager::PopShader()
+{
+	if (ShaderNameStack.size() <= 1)
+	{
+		throw ErrorToLog("Shader stack underflow!!");
+	}
+	std::string oldShaderName = ShaderNameStack.top();
+
+	ShaderNameStack.pop();
+	std::string shaderName = ShaderNameStack.top();
+	if (oldShaderName != shaderName)
+	{
+		glUseProgram(ShaderList[shaderName]->ShaderProgram);
+	}
+}
+
+//========================================================
+//======================== Utilities =====================
+//========================================================
+
+void RenderUniform1f(const std::string& uniformName, const float value)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->UniformList.count(uniformName) > 0)
+				glUniform1fv(ResourceManager->ShaderManager.GetCurrentShader()->UniformList[uniformName],1,&value);
+}
+
+void RenderUniform3fv(const std::string& uniformName, const float* value)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->UniformList.count(uniformName) > 0)
+				glUniform3fv(ResourceManager->ShaderManager.GetCurrentShader()->UniformList[uniformName],1,value);
+}
+
+void RenderUniform4fv(const std::string& uniformName, const float* value)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->UniformList.count(uniformName) > 0)
+				glUniform4fv(ResourceManager->ShaderManager.GetCurrentShader()->UniformList[uniformName],1,value);
+}
+
+
+void RenderUniformMatrix3fv(const std::string& uniformName,bool transpose, const float* value)
+{
+	if (ResourceManager != NULL)	
+			if (ResourceManager->ShaderManager.GetCurrentShader()->UniformList.count(uniformName) > 0)
+				glUniformMatrix3fv(ResourceManager->ShaderManager.GetCurrentShader()->UniformList[uniformName],1,transpose,value);
+			
+}
+
+void RenderUniformMatrix4fv(const std::string& uniformName,bool transpose, const float* value)
+{
+	if (ResourceManager != NULL)	
+			if (ResourceManager->ShaderManager.GetCurrentShader()->UniformList.count(uniformName) > 0)
+				glUniformMatrix4fv(ResourceManager->ShaderManager.GetCurrentShader()->UniformList[uniformName],1,transpose,value);
+			
+}
+
+
+void RenderUniform1i(const std::string& uniformName, const int value)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->UniformList.count(uniformName) > 0)
+				glUniform1i(ResourceManager->ShaderManager.GetCurrentShader()->UniformList[uniformName],value);
+}
+
+void VertexAttrib2fv(const std::string& attribName, const float* value)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				glVertexAttrib2fv(ResourceManager->ShaderManager.GetCurrentShader()->AttribList[attribName], value);
+}
+
+void VertexAttrib3fv(const std::string& attribName, const float* value)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				glVertexAttrib3fv(ResourceManager->ShaderManager.GetCurrentShader()->AttribList[attribName], value);
+}
+
+void VertexAttribPointer2fv(const std::string& attribName,int stride, const char* pointer)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				glVertexAttribPointer(ResourceManager->ShaderManager.GetCurrentShader()->AttribList[attribName], 2, GL_FLOAT, GL_FALSE, stride, pointer);
+}
+
+void VertexAttribPointer3fv(const std::string& attribName,int stride, const char* pointer)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				glVertexAttribPointer(ResourceManager->ShaderManager.GetCurrentShader()->AttribList[attribName], 3, GL_FLOAT, GL_FALSE, stride, pointer);
+}
+
+void EnableVertexAttribArray(const std::string& attribName)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				glEnableVertexAttribArray(ResourceManager->ShaderManager.GetCurrentShader()->AttribList[attribName]);
+}
+
+void DisableVertexAttribArray(const std::string& attribName)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				glDisableVertexAttribArray(ResourceManager->ShaderManager.GetCurrentShader()->AttribList[attribName]);
+}
+
+
+#ifdef TARGET_WIN32
+void RefreshAttribBuffer2fv(const std::string& attribName, std::map<std::string, std::vector<vec2> >& vec2CoordArr)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				if (vec2CoordArr[attribName].size() > 0)
+					glBufferData(GL_ARRAY_BUFFER, vec2CoordArr[attribName].size()*8, &(*vec2CoordArr[attribName].begin()), GL_STATIC_DRAW);
+	
+}
+
+void RefreshAttribBuffer3fv(const std::string& attribName, std::map<std::string, std::vector<vec3> >& vec3CoordArr)
+{
+	if (ResourceManager != NULL)
+			if (ResourceManager->ShaderManager.GetCurrentShader()->AttribList.count(attribName) > 0)
+				if (vec3CoordArr[attribName].size() > 0)
+					glBufferData(GL_ARRAY_BUFFER, vec3CoordArr[attribName].size()*12, &(*vec3CoordArr[attribName].begin()), GL_STATIC_DRAW);
+}
+#endif
+
+} //namespace SE

src/SimpleLand/SimpleLand.cpp

@@ -0,0 +1,826 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+const float CONST_LAND_Y_LIMIT = 15.0f;
+//Limit for y pos of land (edge or trench/dip)
+
+const float CONST_MIN_COS_BETWEEN_CURSOR_AND_VERTEX = 0.99f;
+//See CalcCrossing() for explanation
+
+
+TSimpleLandClass::TSimpleLandClass()
+	: Width(CONST_DEFAULT_LAND_WIDTH),
+	Height(CONST_DEFAULT_LAND_HEIGHT),
+	CellInterval(CONST_DEFAULT_LAND_CELL_INVERVAL),
+	TexID(0),
+	NormTexID(0)
+{
+	int k;
+	
+	VertexMatrix.resize(Width*Height);
+	
+	for (int i=0; i<Height; i++)
+		for (int j=0; j<Width; j++)
+		{
+			k = j + i*Width;
+			VertexMatrix[k].norm = vec3(0.0f, 1.0f, 0.0f);
+			VertexMatrix[k].tangent = vec3(0.0f, 0.0f, 1.0f);
+			VertexMatrix[k].binorm = vec3(1.0f, 0.0f, 0.0f);
+
+			VertexMatrix[k].pos = vec3(
+				j*CellInterval - (CellInterval*Width)/2.0f,
+				1.0f,
+				i*CellInterval - (CellInterval*Height)/2.0f);
+
+			VertexMatrix[k].landtype = rand() % 2;
+		}
+
+	TriangleMatrix.resize(2*(Width-1)*(Height-1));
+	
+	UpdateTriangleMatrix();
+
+	CreateVBO();
+}
+
+TSimpleLandClass::~TSimpleLandClass()
+{
+	FreeVBO();
+
+	TriangleMatrix.clear();
+	VertexMatrix.clear();
+	
+	if (TexID != 0)
+	{
+		ResourceManager->TexList.DeleteTexture(TexID);
+		TexID = 0;
+	}
+
+	if (NormTexID != 0)
+	{
+		ResourceManager->TexList.DeleteTexture(NormTexID);
+		NormTexID = 0;
+	}
+
+}
+
+void TSimpleLandClass::CreateVBO()
+{
+	IndexArr.resize(6*(Width-1)*(Height-1));
+	
+	//VBOLandVertexArr.resize(Width*Height);
+	VBOLandVertexArr.pos.resize(Width * Height);
+	VBOLandVertexArr.norm.resize(Width * Height);
+	VBOLandVertexArr.tangent.resize(Width * Height);
+	VBOLandVertexArr.binorm.resize(Width * Height);
+	VBOLandVertexArr.texCoord.resize(Width * Height);
+
+	for (int i = 0; i < Height-1; i++)
+		for (int j = 0; j < Width-1; j++)
+		{
+			
+			IndexArr[6*(j + i*(Width-1))] = j + i*(Width);
+			IndexArr[6*(j + i*(Width-1)) + 1] = j + 1 + i*(Width);
+			IndexArr[6*(j + i*(Width-1)) + 2] = Width + j + i*(Width);
+
+			IndexArr[6*(j + i*(Width-1)) + 3] = j + 1 + i*(Width);
+			IndexArr[6*(j + i*(Width-1)) + 4] = Width + 1 + j + i*(Width);
+			IndexArr[6*(j + i*(Width-1)) + 5] = Width + j + i*(Width);
+			
+		}
+
+	for (int i = 0; i < Height-1; i++)
+		for (int j = 0; j < Width-1; j++)
+		{
+			VBOLandVertexArr.pos[j + i*Width] = VertexMatrix[j + i*Width].pos;
+			VBOLandVertexArr.norm[j + i*Width] = VertexMatrix[j + i*Width].norm;
+			VBOLandVertexArr.tangent[j + i*Width] = VertexMatrix[j + i*Width].tangent;
+			VBOLandVertexArr.binorm[j + i*Width] = VertexMatrix[j + i*Width].binorm;
+			VBOLandVertexArr.texCoord[j + i*Width].v[0] = float(j) / Width;
+			VBOLandVertexArr.texCoord[j + i*Width].v[1] = float(i) / Height;
+		}
+
+#ifdef TARGET_WIN32
+	glGenBuffers(1, &IndexBuffer);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6*(Width-1)*(Height-1)*4, &IndexArr[0], GL_STATIC_DRAW);
+
+	glGenBuffers(1, &VertexBuffer);
+	glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
+	glBufferData(GL_ARRAY_BUFFER, Width * Height * sizeof(vec3), &(VBOLandVertexArr.pos[0]), GL_STATIC_DRAW);
+
+	glGenBuffers(1, &NormBuffer);
+	glBindBuffer(GL_ARRAY_BUFFER, NormBuffer);
+	glBufferData(GL_ARRAY_BUFFER, Width * Height * sizeof(vec3), &(VBOLandVertexArr.norm[0]), GL_STATIC_DRAW);
+
+	glGenBuffers(1, &TangentBuffer);
+	glBindBuffer(GL_ARRAY_BUFFER, TangentBuffer);
+	glBufferData(GL_ARRAY_BUFFER, Width * Height * sizeof(vec3), &(VBOLandVertexArr.tangent[0]), GL_STATIC_DRAW);
+
+	glGenBuffers(1, &BinormBuffer);
+	glBindBuffer(GL_ARRAY_BUFFER, BinormBuffer);
+	glBufferData(GL_ARRAY_BUFFER, Width * Height * sizeof(vec3), &(VBOLandVertexArr.binorm[0]), GL_STATIC_DRAW);
+
+	glGenBuffers(1, &TexcoordBuffer);
+	glBindBuffer(GL_ARRAY_BUFFER, TexcoordBuffer);
+	glBufferData(GL_ARRAY_BUFFER, Width * Height * sizeof(vec2), &(VBOLandVertexArr.texCoord[0]), GL_STATIC_DRAW);
+#endif
+
+}
+
+void TSimpleLandClass::FreeVBO()
+{
+#ifdef TARGET_WIN32
+	glDeleteBuffers(1, &VertexBuffer);
+	glDeleteBuffers(1, &NormBuffer);
+	glDeleteBuffers(1, &TangentBuffer);
+	glDeleteBuffers(1, &BinormBuffer);
+	glDeleteBuffers(1, &TexcoordBuffer);
+	glDeleteBuffers(1, &IndexBuffer);
+#endif
+
+	VBOLandVertexArr.pos.clear();
+	VBOLandVertexArr.norm.clear();
+	VBOLandVertexArr.tangent.clear();
+	VBOLandVertexArr.binorm.clear();
+	VBOLandVertexArr.texCoord.clear();
+	IndexArr.clear();
+}
+
+void TSimpleLandClass::UpdateVBO()
+{
+	//Index array remains the same - only vertex array is to be changed
+
+	for (int i = 0; i < Height; i++)
+	{
+		for (int j = 0; j < Width; j++)
+		{
+			VBOLandVertexArr.pos[j + i*Width] = VertexMatrix[j + i*Width].pos;
+			VBOLandVertexArr.norm[j + i*Width] = VertexMatrix[j + i*Width].norm;
+			VBOLandVertexArr.tangent[j + i*Width] = VertexMatrix[j + i*Width].tangent;
+			VBOLandVertexArr.binorm[j + i*Width] = VertexMatrix[j + i*Width].binorm;
+			VBOLandVertexArr.texCoord[j + i*Width].v[0] = float(j) / Width;
+			VBOLandVertexArr.texCoord[j + i*Width].v[1] = float(i) / Height;
+		}
+	}
+
+#ifdef TARGET_WIN32
+	
+	glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
+	glBufferSubData(GL_ARRAY_BUFFER, 0,  Width * Height * sizeof(vec3), &(VBOLandVertexArr.pos[0]));
+
+	glBindBuffer(GL_ARRAY_BUFFER, NormBuffer);
+	glBufferSubData(GL_ARRAY_BUFFER, 0,  Width * Height * sizeof(vec3), &(VBOLandVertexArr.norm[0]));
+
+	glBindBuffer(GL_ARRAY_BUFFER, TangentBuffer);
+	glBufferSubData(GL_ARRAY_BUFFER, 0,  Width * Height * sizeof(vec3), &(VBOLandVertexArr.tangent[0]));
+
+	glBindBuffer(GL_ARRAY_BUFFER, BinormBuffer);
+	glBufferSubData(GL_ARRAY_BUFFER, 0,  Width * Height * sizeof(vec3), &(VBOLandVertexArr.binorm[0]));
+
+	glBindBuffer(GL_ARRAY_BUFFER, TexcoordBuffer);
+	glBufferSubData(GL_ARRAY_BUFFER, 0,  Width * Height * sizeof(vec2), &(VBOLandVertexArr.texCoord[0]));
+#endif
+}
+
+vec3 TSimpleLandClass::CalcCrossingForPoint(const vec3& pos, int i, int j)
+{
+	vec3 lineFrom = pos;
+	vec3 lineTo = pos;
+	
+	lineFrom.v[1] = CONST_LAND_Y_LIMIT;
+	lineTo.v[1] = -CONST_LAND_Y_LIMIT;
+
+	vec3 r = CalcCrossingForPoint(lineFrom, lineTo, i, j);
+
+	if (r == lineFrom)
+		return pos;
+	
+	return r;
+}
+
+vec3 TSimpleLandClass::CalcCrossingForPoint(const vec3& lineFrom,const  vec3& lineTo, int i, int j)
+{
+	if (i >= Height-1 || i < 0 || j >= Width-1 || j < 0)
+		return lineFrom;
+
+	TSmpTriangle tr;
+	vec3 r;
+
+
+	tr.p[0] = VertexMatrix[j + i*Width].pos;
+	tr.p[1] = VertexMatrix[(j+1) + i*Width].pos;
+	tr.p[2] = VertexMatrix[(j+1) + (i+1)*Width].pos;
+
+	tr.v = tr.p[1] - tr.p[0];
+	tr.w = tr.p[2] - tr.p[1];
+	tr.n = CrossProduct(tr.v, tr.w);
+
+	if (LineCrossTriangle(lineFrom, lineTo, tr, r) == 1)
+		return r;
+
+	tr.p[0] = VertexMatrix[j + i*Width].pos;
+	tr.p[1] = VertexMatrix[j + (i+1)*Width].pos;
+	tr.p[2] = VertexMatrix[(j+1) + (i+1)*Width].pos;
+
+	tr.v = tr.p[1] - tr.p[0];
+	tr.w = tr.p[2] - tr.p[1];
+	tr.n = CrossProduct(tr.v, tr.w);
+
+	if (LineCrossTriangle(lineFrom, lineTo, tr, r) == 1)
+		return r;
+
+	return lineFrom;
+}
+
+bool TSimpleLandClass::LoadFromFile(const std::string& filename)
+{
+
+	cardinal dwordCount;
+	boost::shared_array<cardinal> fileArr = CreateMemFromFile<cardinal>((ResourceManager->PathToResources + filename).c_str(), dwordCount);
+
+	if ((((char*)&fileArr[0])[0]!='L')||
+		(((char*)&fileArr[0])[1]!='S')||
+		(((char*)&fileArr[0])[2]!=0)||
+		(((char*)&fileArr[0])[3]!=1))
+		throw ErrorFileNotCorrect(filename);
+
+	Width = fileArr[1];
+	Height = fileArr[2];
+	CellInterval = ((float*)&fileArr[0])[3];
+
+	std::vector<TSimpleLandVertex> tempVertexMatrix; 
+	tempVertexMatrix.resize(Width*Height);
+
+
+	for (int i = 0; i < Height; i++)
+		for (int j = 0; j < Width; j++)
+		{
+			int k = j + i * Width;
+			tempVertexMatrix[k] = ((TSimpleLandVertex*)(&fileArr[0] + 4))[k];
+		}
+
+	//Replace old matrices with new
+
+	TriangleMatrix.resize(2*(Width-1)*(Height-1));
+	VertexMatrix = tempVertexMatrix;
+	
+	UpdateTriangleMatrix();
+
+	RecalcNormalVectors();
+
+	FreeVBO();
+	CreateVBO();
+
+	return true;
+}
+
+
+
+void TSimpleLandClass::SaveToFile(char* filename)
+{
+	//NIU
+
+	//Need to clean up
+#ifdef TARGET_WIN32
+
+	OFSTRUCT ofstruct;
+	DWORD FSize;
+	DWORD BytesWriten;
+	char* FileArr;
+
+	//Îòêðûâàåì ôàéë
+	HANDLE h=(HANDLE)OpenFile(filename,&ofstruct,OF_CREATE);
+
+	FSize = 16 + Width*Height*sizeof(TSimpleLandVertex);
+
+	FileArr = new char [FSize];
+
+	FileArr[0] = 'L';
+	FileArr[1] = 'S';
+	FileArr[2] = 0;
+	FileArr[3] = 1;
+
+	((int*)FileArr)[1] = Width;
+	((int*)FileArr)[2] = Height;
+	((float*)FileArr)[3] = CellInterval;
+
+	int k;
+
+	for (int i=0;i<Height;i++)
+		for (int j=0;j<Width;j++)
+		{
+			k = j+i*Width;
+			((TSimpleLandVertex*)(FileArr + 16))[k] = VertexMatrix[k];
+		}
+
+	WriteFile(h,FileArr,FSize,&BytesWriten,NULL);
+
+	delete [] FileArr;
+	CloseHandle(h);
+#endif
+}
+
+void TSimpleLandClass::SetTexture(const std::string& texFilename)
+{
+	if (TexID != 0)
+	{
+		ResourceManager->TexList.DeleteTexture(TexID);
+	}
+	TexID = ResourceManager->TexList.AddTexture(texFilename);
+}
+
+void TSimpleLandClass::SetNormTexture(const std::string& normTexFilename)
+{
+	if (NormTexID != 0)
+	{
+		ResourceManager->TexList.DeleteTexture(NormTexID);
+	}
+	NormTexID = ResourceManager->TexList.AddTexture(normTexFilename);
+}
+
+
+
+
+void TSimpleLandClass::DrawImmediate()
+{
+	//Need to speed up!
+	
+#ifdef TARGET_WIN32
+
+	int i, j, k, k_up, k_right, k_right_up;
+
+	if (NormTexID == 0)
+	{
+		RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, 0);
+	}
+
+	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,WhiteColor);
+
+	RenderUniformMatrix3fv(CONST_STRING_MODELROTATEMATRIX_UNIFORM, false, (float*)IdentityMatrix.m);
+	RenderUniform3fv(CONST_STRING_MODELTRANSLATEVECTOR_UNIFORM, (float*)ZeroVec3.v);
+
+	glActiveTexture(GL_TEXTURE1);
+	glBindTexture(GL_TEXTURE_2D, NormTexID);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, TexID);
+
+	for (i = 0; i < Height-1; i++)
+		for (j = 0; j < Width-1; j++)
+		{
+			k = j + i*Width;
+			k_right = (j+1) + i*Width;
+			k_up = j + (i+1)*Width;
+			k_right_up = (j+1) + (i+1)*Width;
+
+			float tx0 = float(j)/(Width-1);
+			float ty0 = float(i)/(Height-1);
+
+			float tx1 = float(j+1)/(Width-1);
+			float ty1 = float(i+1)/(Height-1);
+
+			glBegin(GL_TRIANGLES);
+				glNormal3fv(VertexMatrix[k].norm.v);
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, VertexMatrix[k].tangent.v);
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, VertexMatrix[k].binorm.v);
+				glTexCoord2f(tx0,ty0);
+				glVertex3fv(VertexMatrix[k].pos.v);
+
+				glNormal3fv(VertexMatrix[k_right].norm.v);
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, VertexMatrix[k_right].tangent.v);
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, VertexMatrix[k_right].binorm.v);
+				glTexCoord2f(tx1,ty0);
+				glVertex3fv(VertexMatrix[k_right].pos.v);
+
+				glNormal3fv(VertexMatrix[k_up].norm.v);
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, VertexMatrix[k_up].tangent.v);
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, VertexMatrix[k_up].binorm.v);
+				glTexCoord2f(tx0,ty1);
+				glVertex3fv(VertexMatrix[k_up].pos.v);
+			glEnd();
+			
+			glBegin(GL_TRIANGLES);
+				glNormal3fv(VertexMatrix[k_right_up].norm.v);
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, VertexMatrix[k_right_up].tangent.v);
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, VertexMatrix[k_right_up].binorm.v);
+				glTexCoord2f(tx1,ty1);
+				glVertex3fv(VertexMatrix[k_right_up].pos.v);
+
+				glNormal3fv(VertexMatrix[k_up].norm.v);
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, VertexMatrix[k_up].tangent.v);
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, VertexMatrix[k_up].binorm.v);
+				glTexCoord2f(tx0,ty1);
+				glVertex3fv(VertexMatrix[k_up].pos.v);
+
+				glNormal3fv(VertexMatrix[k_right].norm.v);
+				VertexAttrib3fv(CONST_STRING_TANGENT_ATTRIB, VertexMatrix[k_right].tangent.v);
+				VertexAttrib3fv(CONST_STRING_BINORMAL_ATTRIB, VertexMatrix[k_right].binorm.v);
+				glTexCoord2f(tx1,ty0);
+				glVertex3fv(VertexMatrix[k_right].pos.v);
+			glEnd();
+
+		}
+
+		RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, 1);
+
+#endif
+}
+
+void TSimpleLandClass::DrawVBO()
+{
+
+
+	//RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, min<cardinal>(NormTexID, 1));
+	
+	//RenderUniformMatrix3fv(CONST_STRING_MODELROTATEMATRIX_UNIFORM, false, (float*)IdentityMatrix.m);
+	//RenderUniform3fv(CONST_STRING_MODELTRANSLATEVECTOR_UNIFORM, (float*)ZeroVec3.v);
+
+	if (NormTexID != 0)
+	{
+		glActiveTexture(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D,NormTexID);
+	}
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,TexID);
+
+	
+#ifdef TARGET_WIN32
+	
+	
+	glBindBuffer(GL_ARRAY_BUFFER, NormBuffer);
+	VertexAttribPointer3fv(CONST_STRING_NORMAL_ATTRIB, 0, (char*)NULL);
+
+	glBindBuffer(GL_ARRAY_BUFFER, TangentBuffer);
+	VertexAttribPointer3fv(CONST_STRING_TANGENT_ATTRIB, 0, (char*)NULL);
+
+	glBindBuffer(GL_ARRAY_BUFFER, BinormBuffer);
+	VertexAttribPointer3fv(CONST_STRING_BINORMAL_ATTRIB, 0, (char*)NULL);
+
+	glBindBuffer(GL_ARRAY_BUFFER, TexcoordBuffer);
+	VertexAttribPointer2fv(CONST_STRING_TEXCOORD_ATTRIB, 0, (char*)NULL);
+	
+	glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
+	VertexAttribPointer3fv(CONST_STRING_POSITION_ATTRIB, 0, (char*)NULL);
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBuffer);
+
+	glDrawElements(GL_TRIANGLES, 6*(Width-1)*(Height-1), GL_UNSIGNED_INT, NULL);
+
+	
+#endif
+#ifdef TARGET_ANDROID
+	
+	
+	VertexAttribPointer3fv(CONST_STRING_NORMAL_ATTRIB, 0, reinterpret_cast<const char*>(&(VBOLandVertexArr.norm[0])));
+
+	VertexAttribPointer3fv(CONST_STRING_TANGENT_ATTRIB, 0, reinterpret_cast<const char*>(&(VBOLandVertexArr.tangent[0])));
+
+	VertexAttribPointer3fv(CONST_STRING_BINORMAL_ATTRIB, 0, reinterpret_cast<const char*>(&(VBOLandVertexArr.binorm[0])));
+	
+	VertexAttribPointer2fv(CONST_STRING_TEXCOORD_ATTRIB, 0, reinterpret_cast<const char*>(&(VBOLandVertexArr.texCoord[0])));
+	
+	VertexAttribPointer3fv(CONST_STRING_POSITION_ATTRIB, 0, reinterpret_cast<const char*>(&(VBOLandVertexArr.pos[0])));
+	
+	glDrawElements(GL_TRIANGLES, 6*(Width-1)*(Height-1), GL_UNSIGNED_SHORT, &IndexArr[0]);
+
+#endif
+
+	RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM,1);
+
+}
+
+vec3 TSimpleLandClass::CalcCrossing(vec3 LineFrom,vec3 LineTo)
+{
+	int i, j;
+	vec3 CursorVec = Normalize(LineTo - LineFrom);
+	vec3 CamPos = Renderer->GetCamPos();
+	
+	for (i = 0; i < Height-1; i++)
+		for (j = 0; j < Width-1; j++)
+		{
+			vec3 CamToVertex = Normalize(VertexMatrix[j + i*Width].pos - CamPos);
+			float cosA = DotProduct(CamToVertex, CursorVec);
+			
+			if (cosA > CONST_MIN_COS_BETWEEN_CURSOR_AND_VERTEX)
+			{
+				vec3 r = CalcCrossingForPoint(LineFrom, LineTo, i, j);
+
+				if (!(r == LineFrom))
+					return r;
+			}
+		}
+
+	return LineFrom;
+}
+
+vec3 TSimpleLandClass::CalcVerticalCrossing(const vec3& pos)
+{
+	int ir = -1;
+	int jr = -1;
+	
+	float xMin = VertexMatrix[0].pos.v[0];
+	float xMax = VertexMatrix[Width-1].pos.v[0];
+
+	float yMin = VertexMatrix[Height*Width-1].pos.v[2];
+	float yMax = VertexMatrix[0].pos.v[2];
+
+	jr = static_cast<int>(floor((Width-1)*(pos.v[0]-xMin)/(xMax - xMin)));
+	ir = static_cast<int>(floor((Height-1)*(pos.v[2]-yMax)/(yMin - yMax))); //Must be reversed
+	
+
+	if (ir < 0 || ir >= Height-1 || jr < 0 || jr >= Width-1)
+	{
+		return pos;
+	}
+	else
+	{
+		vec3 r;
+		r = CalcCrossingForPoint(pos, ir, jr);
+		//r = CalcCrossingForPoint(r, ir+1, jr);
+		//r = CalcCrossingForPoint(r, ir+2, jr);
+		//r = CalcCrossingForPoint(r, ir-1, jr);
+		//r = CalcCrossingForPoint(r, ir-2, jr);
+		return r;
+	}
+
+}
+
+float TSimpleLandClass::CalcVerticalCrossingFast(const vec3& pos)
+{
+	int ir = -1;
+	int jr = -1;
+	
+	float xMin = VertexMatrix[0].pos.v[0];
+	float xMax = VertexMatrix[Width-1].pos.v[0];
+
+	float zMin = VertexMatrix[Height*Width-1].pos.v[2];
+	float zMax = VertexMatrix[0].pos.v[2];
+
+	float w = (xMax - xMin) / (Width-1);
+	float h = (zMax - zMin) / (Height-1);
+
+	jr = int((pos.v[0] - xMin)/w);
+	ir = (Height-1) - int(ceilf((pos.v[2] - zMin)/h));
+
+	if (ir < 0 || ir >= Height-1 || jr < 0 || jr >= Width-1)
+	{
+		return pos.v[1];
+	}
+	else
+	{
+		return max(VertexMatrix[jr + ir*Width].pos.v[1], 
+			max(VertexMatrix[(jr+1) + ir*Width].pos.v[1], 
+			max(VertexMatrix[jr + (ir+1)*Width].pos.v[1],
+			VertexMatrix[(jr+1) + (ir+1)*Width].pos.v[1])));
+	}
+
+
+}
+
+bool TSimpleLandClass::IsOnTheLand(const vec3& pos)
+{
+
+	float xMin = VertexMatrix[0].pos.v[0];
+	float xMax = VertexMatrix[Width-1].pos.v[0];
+
+	float yMin = VertexMatrix[Height*Width-1].pos.v[2];
+	float yMax = VertexMatrix[0].pos.v[2];
+	
+	return (pos.v[0] >= xMin) && (pos.v[0] <= xMax) && (pos.v[2] >= yMin) && (pos.v[2] <= yMax);
+
+}
+
+void TSimpleLandClass::MoveLandUp(vec3 CursorPos,float R)
+{
+	//NIU
+	int i,j;
+	vec3 pointpos;
+	float r,k;
+
+	for (i=0;i<Height;i++)
+		for (j=0;j<Width;j++)
+		{
+			pointpos = VertexMatrix[j+i*Width].pos;
+			r = sqrtf((pointpos.v[0]-CursorPos.v[0])*(pointpos.v[0]-CursorPos.v[0])+(pointpos.v[2]-CursorPos.v[2])*(pointpos.v[2]-CursorPos.v[2]));
+			if (r<R)
+			{
+				k=sqrtf((R-r)/R);
+				VertexMatrix[j+i*Width].pos.v[1] += k*CONST_LAND_MOVE_STEP;
+			}
+		}
+	RecalcNormalVectors();
+	UpdateTriangleMatrix();
+
+	UpdateVBO();
+}
+
+void TSimpleLandClass::MoveLandDown(vec3 CursorPos,float R)
+{
+	//NIU
+	int i,j;
+	vec3 pointpos;
+	float r,k;
+
+	for (i=0;i<Height;i++)
+		for (j=0;j<Width;j++)
+		{
+			pointpos = VertexMatrix[j+i*Width].pos;
+			r = sqrtf((pointpos.v[0]-CursorPos.v[0])*(pointpos.v[0]-CursorPos.v[0])+(pointpos.v[2]-CursorPos.v[2])*(pointpos.v[2]-CursorPos.v[2]));
+			if (r<R)
+			{
+				k=sqrtf((R-r)/R);
+				VertexMatrix[j+i*Width].pos.v[1] -= k*CONST_LAND_MOVE_STEP;
+			}
+		}
+	RecalcNormalVectors();
+	UpdateTriangleMatrix();
+
+	UpdateVBO();
+}
+void TSimpleLandClass::SmoothLand(vec3 CursorPos,float R)
+{
+	//NIU
+	int i,j;
+	vec3 pointpos;
+	float r,k;
+	float h1,h2,h3,h4;
+
+	for (i=0;i<Height;i++)
+		for (j=0;j<Width;j++)
+		{
+			pointpos = VertexMatrix[j+i*Width].pos;
+			r = sqrtf((pointpos.v[0]-CursorPos.v[0])*(pointpos.v[0]-CursorPos.v[0])+(pointpos.v[2]-CursorPos.v[2])*(pointpos.v[2]-CursorPos.v[2]));
+			if (r<R)
+			{
+				k = sqrtf((R-r)/R);
+
+				h1 = (i>0) ? VertexMatrix[j+(i-1)*Width].pos.v[1] : pointpos.v[1];
+				h2 = (j>0) ? VertexMatrix[j-1+i*Width].pos.v[1] : pointpos.v[1];
+
+				h3 = (i<Height-1) ? VertexMatrix[j+(i+1)*Width].pos.v[1] : pointpos.v[1];
+				h4 = (j<Width-1) ? VertexMatrix[j+1+i*Width].pos.v[1] : pointpos.v[1];
+
+				h1 = (h1+h2+h3+h4)/4.0f - pointpos.v[1];
+
+				VertexMatrix[j+i*Width].pos.v[1] += h1;
+			}
+		}
+	RecalcNormalVectors();
+	UpdateTriangleMatrix();
+
+	UpdateVBO();
+}
+
+void TSimpleLandClass::TextureLand(vec3 CursorPos,float R,int ltype)
+{
+	//NIU
+	int i,j;
+	vec3 pointpos;
+	float r;
+
+	for (i=0;i<Height;i++)
+		for (j=0;j<Width;j++)
+		{
+			pointpos = VertexMatrix[j+i*Width].pos;
+			r = sqrtf((pointpos.v[0]-CursorPos.v[0])*(pointpos.v[0]-CursorPos.v[0])+(pointpos.v[2]-CursorPos.v[2])*(pointpos.v[2]-CursorPos.v[2]));
+			if (r<R)
+			{
+				VertexMatrix[j+i*Width].landtype = ltype;
+			}
+		}
+}
+
+void TSimpleLandClass::Scale(float s)
+{
+	for (int i = 0; i < Height; i++)
+		for (int j = 0; j < Width; j++)
+		{
+			VertexMatrix[j + i*Width].pos *= s;
+		}
+
+	RecalcNormalVectors();
+	UpdateTriangleMatrix();
+
+	UpdateVBO();
+}
+
+void TSimpleLandClass::Scale(vec3 s)
+{
+	for (int i = 0; i < Height; i++)
+	{
+		for (int j = 0; j < Width; j++)
+		{
+			VertexMatrix[j + i*Width].pos.v[0] *= s.v[0];
+			VertexMatrix[j + i*Width].pos.v[1] *= s.v[1];
+			VertexMatrix[j + i*Width].pos.v[2] *= s.v[2];
+		}
+	}
+
+	RecalcNormalVectors();
+	UpdateTriangleMatrix();
+
+	UpdateVBO();
+}
+
+void TSimpleLandClass::Move(const vec3& v)
+{
+	for (int i = 0; i < Height; i++)
+		for (int j = 0; j < Width; j++)
+		{
+			VertexMatrix[j + i*Width].pos = VertexMatrix[j + i*Width].pos + v;
+		}
+
+	RecalcNormalVectors();
+	UpdateTriangleMatrix();
+
+	UpdateVBO();
+}
+
+int TSimpleLandClass::GetWidth() 
+{ 
+	return Width; 
+};
+
+int TSimpleLandClass::GetHeight() 
+{ 
+	return Height; 
+};
+	
+float* TSimpleLandClass::GetTriangleMatrix() 
+{
+	return (float*)&TriangleMatrix[0]; 
+};
+
+void TSimpleLandClass::RecalcNormalVectors()
+{
+	int i,j,ifrom,ito,jfrom,jto;
+	vec3 v1,v2;
+
+	for (i=0;i<Height;i++)
+		for (j=0;j<Width;j++)
+		{
+			ifrom = (i==0) ? i : i-1;
+			jfrom = (j==0) ? j : j-1;
+			ito = (i==Height-1) ? Height-1 : i+1;
+			jto = (j==Width-1) ? Width-1 : j+1;
+
+			
+			v1 = VertexMatrix[j+ito*Width].pos - VertexMatrix[j+ifrom*Width].pos;
+
+			v2 = VertexMatrix[jto+i*Width].pos - VertexMatrix[jfrom+i*Width].pos;
+	
+			VertexMatrix[j+i*Width].binorm = v1;
+			VertexMatrix[j+i*Width].tangent = v2;
+			VertexMatrix[j+i*Width].norm = CrossProduct(v2, v1);
+
+		}
+}
+
+
+void TSimpleLandClass::UpdateTriangleMatrix()
+{
+	int k;
+	vec3 v,w;
+	for (int i=0;i<Height-1;i++)
+		for (int j=0;j<Width-1;j++)
+		{
+			k = 2*(j + i*(Width-1));
+			TriangleMatrix[k].PointList[0] = VertexMatrix[j + i*(Width)].pos;
+			TriangleMatrix[k].PointList[1] = VertexMatrix[j+1 + i*(Width)].pos;
+			TriangleMatrix[k].PointList[2] = VertexMatrix[j + (i+1)*(Width)].pos;
+			v =  TriangleMatrix[k].PointList[1] - TriangleMatrix[k].PointList[0];
+			w =  TriangleMatrix[k].PointList[2] - TriangleMatrix[k].PointList[1];
+
+			TriangleMatrix[k].NormVec = CrossProduct(v,w);
+			if (TriangleMatrix[k].NormVec.v[1] < 0.0f)
+			{
+				//Xperimental
+				TriangleMatrix[k].NormVec.v[0] = - TriangleMatrix[k].NormVec.v[0];
+				TriangleMatrix[k].NormVec.v[1] = - TriangleMatrix[k].NormVec.v[1];
+				TriangleMatrix[k].NormVec.v[2] = - TriangleMatrix[k].NormVec.v[2];
+			}
+
+			k++;
+
+			TriangleMatrix[k].PointList[0] = VertexMatrix[j+1 + (i+1)*(Width)].pos;
+			TriangleMatrix[k].PointList[1] = VertexMatrix[j + (i+1)*(Width)].pos;
+			TriangleMatrix[k].PointList[2] = VertexMatrix[j+1 + i*(Width)].pos;
+			v =  TriangleMatrix[k].PointList[1] - TriangleMatrix[k].PointList[0];
+			w =  TriangleMatrix[k].PointList[2] - TriangleMatrix[k].PointList[1];
+
+			TriangleMatrix[k].NormVec = CrossProduct(v, w);
+			if (TriangleMatrix[k].NormVec.v[1] < 0.0f)
+			{
+				//Xperimental
+				TriangleMatrix[k].NormVec.v[0] = - TriangleMatrix[k].NormVec.v[0];
+				TriangleMatrix[k].NormVec.v[1] = - TriangleMatrix[k].NormVec.v[1];
+				TriangleMatrix[k].NormVec.v[2] = - TriangleMatrix[k].NormVec.v[2];
+			}
+			
+		}
+}
+
+} //namespace SE

src/SmartValueManager/SmartValueManager.cpp

@@ -0,0 +1,59 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+TSmartValue& TSmartValueManager::GetSmartValue(const std::string& dictName, const std::string& valueName)
+{
+	return DisctionariesMap[dictName][valueName];
+}
+
+
+void TSmartValueManager::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	BOOST_FOREACH(auto& subTree, propertyTree.begin()->second)
+	{
+		std::string dictName = subTree.second.get<std::string>("<xmlattr>.name");
+
+		BOOST_FOREACH(auto& subSubTree, subTree.second)
+		{
+			if (subSubTree.first == "Record")
+			{
+				std::string key = subSubTree.second.get<std::string>("<xmlattr>.key");
+	
+				std::string type = subSubTree.second.get<std::string>("<xmlattr>.type", "");
+
+				if (type == "int")
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<int>>(new TBindableVar<int>(subSubTree.second.get<int>("<xmlattr>.value")));
+				}
+				else if (type == "bool")
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<bool>>(new TBindableVar<bool>(subSubTree.second.get<bool>("<xmlattr>.value")));
+				}
+				else if (type == "float")
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<float>>(new TBindableVar<float>(subSubTree.second.get<float>("<xmlattr>.value")));
+				}
+				else if (type == "vec2")
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<vec2>>(new TBindableVar<vec2>(StringToVec2(subSubTree.second.get<std::string>("<xmlattr>.value"))));
+				}
+				else if (type == "vec3")
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<vec3>>(new TBindableVar<vec3>(StringToVec3(subSubTree.second.get<std::string>("<xmlattr>.value"))));
+				}
+				else if (type == "vec4")
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<vec4>>(new TBindableVar<vec4>(StringToVec4(subSubTree.second.get<std::string>("<xmlattr>.value"))));
+				}
+				else
+				{
+					DisctionariesMap[dictName][key] = std::shared_ptr<TBindableVar<std::string>>(new TBindableVar<std::string>(subSubTree.second.get<std::string>("<xmlattr>.value")));
+				}
+			}
+		}
+	}
+}
+
+} //namespace SE

src/SoundManager/SoundManagerAndroid.cpp

@@ -0,0 +1,48 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+TSoundManagerAndroid::TSoundManagerAndroid()
+{
+}
+
+TSoundManagerAndroid::~TSoundManagerAndroid()
+{
+	JniReleaseAllSoundsAndMusic();
+}
+
+
+void TSoundManagerAndroid::LoadSound(const std::string& soundFileName)
+{
+	JniLoadSound(soundFileName);
+}
+
+void TSoundManagerAndroid::PlaySound(const std::string& soundName)
+{
+	JniPlaySound(soundName);
+}
+
+
+void TSoundManagerAndroid::LoadMusic(const std::string& musicFileName)
+{
+	//dummy. Not needed
+}
+
+void TSoundManagerAndroid::PlayMusic(const std::string& musicName)
+{
+	JniPlayMusic(musicName);
+}
+
+void TSoundManagerAndroid::PlayMusicLooped(const std::string& musicName)
+{
+	JniPlayMusicLooped(musicName);
+}
+
+void TSoundManagerAndroid::StopMusic(const std::string& musicName)
+{
+	JniStopMusic();
+}
+
+
+} //namespace SE

src/SoundManager/SoundManagerDataTypes.cpp

@@ -0,0 +1,92 @@
+#ifndef NOSOUND
+
+#include "include/SoundManager/SoundManagerDataTypes.h"
+
+
+namespace SE
+{
+
+
+extern "C"
+{ 
+size_t OggFileRead(void* toBuf, size_t varsize, size_t varcount, void* fromBuf);
+
+int OggFileSeek(void *fromBuf, ogg_int64_t offset, int whence);
+
+long OggFileTell(void *fromBuf);
+}
+
+size_t OggFileRead(void* toBuf, size_t varsize, size_t varcount, void* fromBuf)
+{
+    TOggCallbackFileBuffer& callbackFileBuffer = *(reinterpret_cast<TOggCallbackFileBuffer*>(fromBuf));
+    
+    if (callbackFileBuffer.FilePos+varsize*varcount > callbackFileBuffer.FileSize)
+    {
+        size_t dataLeft = callbackFileBuffer.FileSize - callbackFileBuffer.FilePos;
+        
+        if (dataLeft != 0)
+        {
+            memcpy(toBuf, &callbackFileBuffer.FileData[callbackFileBuffer.FilePos], dataLeft);
+        }
+        
+        callbackFileBuffer.FilePos += dataLeft;
+  
+        return dataLeft;
+    }
+    else
+    {
+        memcpy(toBuf, &callbackFileBuffer.FileData[callbackFileBuffer.FilePos], varsize*varcount);
+        callbackFileBuffer.FilePos += varsize*varcount;
+ 
+        return varsize*varcount;
+    }
+}
+
+
+
+int OggFileSeek(void *fromBuf, ogg_int64_t offset, int whence)
+{
+    TOggCallbackFileBuffer& callbackFileBuffer = *(reinterpret_cast<TOggCallbackFileBuffer*>(fromBuf));
+
+    size_t newPos;
+    
+    switch(whence)
+    {
+case SEEK_SET:
+        newPos = static_cast<size_t>(offset);
+        break;
+case SEEK_CUR:
+        newPos = static_cast<size_t>(callbackFileBuffer.FilePos + offset);
+        break;
+case SEEK_END:
+        newPos = static_cast<size_t>(callbackFileBuffer.FileSize - 1 - offset);
+        break;
+	};
+    
+    callbackFileBuffer.FilePos = newPos;
+    
+    return 0;
+    
+}
+
+long OggFileTell(void *fromBuf)
+{
+    TOggCallbackFileBuffer& callbackFileBuffer = *(reinterpret_cast<TOggCallbackFileBuffer*>(fromBuf));
+    
+    return callbackFileBuffer.FilePos;
+}
+
+
+
+ov_callbacks OggCallbacks = {
+  (size_t (*)(void *, size_t, size_t, void *))  OggFileRead,
+  (int (*)(void *, ogg_int64_t, int))           OggFileSeek,
+  (int (*)(void *))                             NULL,
+  (long (*)(void *))                            OggFileTell
+};
+
+
+#endif //NOSOUND
+
+
+} //namespace SE

src/SoundManager/SoundManagerIos.mm

@@ -0,0 +1,132 @@
+//
+//  SoundManagerIos.mm
+//  Halibut Engine
+//
+//  Created by vvv ооо on 21.07.12.
+//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
+//
+
+#include <iostream>
+#include <string>
+#include <map>
+
+#import <Foundation/Foundation.h>
+#import "PASoundMgr.h"
+#import "PASoundListener.h"
+#import "PASoundSource.h"
+
+#include "include/Utils/Utils.h"
+
+#include "include/SoundManager/SoundManagerIos.h"
+
+namespace SE
+{
+
+std::map<std::string, PASoundSource*> AudioSourceMap;
+
+TSoundManagerIos::TSoundManagerIos()
+{
+    [PASoundMgr sharedSoundManager];
+    [[[PASoundMgr sharedSoundManager] listener] setPosition:CGPointMake(0, 0)];
+}
+
+TSoundManagerIos::~TSoundManagerIos()
+{
+    for (std::map<std::string, PASoundSource*>::iterator i = AudioSourceMap.begin(); i != AudioSourceMap.end(); ++i)
+    {
+        //[i->second release];
+    }
+    AudioSourceMap.clear();
+}
+
+void TSoundManagerIos::LoadSound(const std::string& soundFileName)
+{
+    LoadMusic(soundFileName);
+}
+
+
+void TSoundManagerIos::PlaySound(const std::string& soundName)
+{
+    PlayMusic(soundName);
+}
+
+void TSoundManagerIos::LoadMusicLooped(const std::string& musicFileName)
+{
+    //Hack for ios, see below
+    std::string musicName = GetFileName(musicFileName);
+    
+    std::string fullFileName = GetPathToResources() + musicFileName;
+    
+    NSString* nsFileName = [NSString stringWithCString:fullFileName.c_str() encoding:NSUTF8StringEncoding];
+    
+    NSString* nsFileNameWithoutExt = [nsFileName stringByDeletingPathExtension];
+    
+    NSString* nsFileExt = [nsFileName pathExtension];
+    
+    if (AudioSourceMap.count(musicName) > 0)
+    {
+        //[AudioSourceMap[musicName] release];
+    }
+    
+    /*AudioSourceMap[musicFileName] = [[[PASoundMgr sharedSoundManager] addSound:@"trance-loop" withExtension:@"ogg" position:CGPointMake(0, 0) looped:NO] retain];*/
+    AudioSourceMap[musicName] = [[PASoundMgr sharedSoundManager] addSound:nsFileNameWithoutExt withExtension:nsFileExt position:CGPointMake(0, 0) looped:YES];
+}
+    
+void TSoundManagerIos::LoadMusic(const std::string& musicFileName)
+{
+    std::string musicName = GetFileName(musicFileName);
+    
+    std::string fullFileName = GetPathToResources() + musicFileName;
+    
+    NSString* nsFileName = [NSString stringWithCString:fullFileName.c_str() encoding:NSUTF8StringEncoding];
+    
+    NSString* nsFileNameWithoutExt = [nsFileName stringByDeletingPathExtension];
+    
+    NSString* nsFileExt = [nsFileName pathExtension];
+    
+    if (AudioSourceMap.count(musicName) > 0)
+    {
+        //[AudioSourceMap[musicName] release];
+    }
+    
+    /*AudioSourceMap[musicFileName] = [[[PASoundMgr sharedSoundManager] addSound:@"trance-loop" withExtension:@"ogg" position:CGPointMake(0, 0) looped:NO] retain];*/
+    AudioSourceMap[musicName] = [[PASoundMgr sharedSoundManager] addSound:nsFileNameWithoutExt withExtension:nsFileExt position:CGPointMake(0, 0) looped:NO];
+}
+
+
+void TSoundManagerIos::PlayMusic(const std::string& musicName)
+{
+    if (AudioSourceMap.count(musicName) == 0)
+    {
+        throw ErrorToLog("Sound or music not exists: "+musicName);
+    }
+    
+    AudioSourceMap[musicName].looped = false;
+    
+    [AudioSourceMap[musicName] playAtListenerPosition];
+}
+
+void TSoundManagerIos::PlayMusicLooped(const std::string& musicName)
+{
+    if (AudioSourceMap.count(musicName) == 0)
+    {
+        throw ErrorToLog("Sound or music not exists: "+musicName);
+    }
+    
+    AudioSourceMap[musicName].looped = true;
+    
+    [AudioSourceMap[musicName] playAtListenerPosition];
+}
+
+void TSoundManagerIos::StopMusic(const std::string& musicName)
+{
+    if (AudioSourceMap.count(musicName) == 0)
+    {
+        throw ErrorToLog("Sound or music not exists: "+musicName);
+    }
+    
+    [AudioSourceMap[musicName] stop];
+}
+
+
+} //namespace SE

src/TextureManager/SalmonTexture.cpp

@@ -0,0 +1,899 @@
+#include "include/TextureManager/SalmonTexture.h"
+
+#include "include/Utils/Utils.h"
+#include "include/Engine.h"
+
+#include "boost/gil/gil_all.hpp"
+#include "boost/gil/extension/numeric/sampler.hpp"
+#include "boost/gil/extension/numeric/resample.hpp"
+
+#include "boost/assign.hpp"
+
+namespace SE
+{
+
+TTextureListClass::TTextureListClass()
+{
+    using namespace boost::assign;
+    
+    using namespace std;
+ 
+	CreateFunctionMap[".bmp"] = boost::bind(&TTextureListClass::CreateTexDataFromBmp24, this, _1, _2);
+	CreateFunctionMap[".bmp32"] = boost::bind(&TTextureListClass::CreateTexDataFromBmp32, this, _1, _2);
+	CreateFunctionMap[".png"] = boost::bind(&TTextureListClass::CreateTexDataFromPng, this, _1, _2);
+	CreateFunctionMap[".tga"] = boost::bind(&TTextureListClass::CreateTexDataFromTga, this, _1, _2);
+    
+	AddFunctionMap["bmp24"] = boost::bind(&TTextureListClass::AddTextureBmp24Data, this, _1);
+	AddFunctionMap["bmp32"] = boost::bind(&TTextureListClass::AddTextureBmp32Data, this, _1);
+    
+}
+
+TTextureListClass::~TTextureListClass() 
+{ 
+	Clear();
+	
+	*Console<<"ResourceManager::TexList deleting";
+}
+
+void TTextureListClass::Clear()
+{
+
+	if (TexMap.size() != 0)
+	{
+        
+        BOOST_FOREACH(auto& i, TexMap)
+        {
+			glDeleteTextures(1,&(i.second.TexID));
+        }
+
+		TexMap.clear();
+
+		*Console<<"ResourceManager::TexList cleared";
+	}
+	
+}
+
+void TTextureListClass::Serialize(boost::property_tree::ptree& propertyTree)
+{
+	
+	BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Textures"))
+	{
+
+		std::string fileName = v.second.get<std::string>("FileName");
+		std::string texName = v.second.get<std::string>("TexName", "");
+
+		AddTexture(fileName, texName);
+
+	}
+}
+
+void TTextureListClass::NormalizeTexData(TTextureData& texData)
+{
+
+	using namespace boost::gil;
+
+	if (IsPower2(texData.Width) && IsPower2(texData.Height))
+	{
+		return;
+	}
+
+	cardinal newWidth = GetGreaterPower2(texData.Width);
+	cardinal newHeight = GetGreaterPower2(texData.Height);
+
+	if (!strcmp(texData.Format, "bmp32"))
+	{
+
+		boost::shared_array<char> newData(new char [newWidth * newHeight * 4]);
+
+		rgba8_view_t oldView = interleaved_view(texData.Width, texData.Height, reinterpret_cast<const rgba8_ptr_t>(texData.Data.get()), texData.DataSize / texData.Height);
+
+		rgba8_image_t newImage(newWidth, newHeight);		
+
+		resize_view(oldView, view(newImage), bilinear_sampler());
+
+		texData.Data = newData;
+		texData.Width = newWidth;
+		texData.Height = newHeight;
+		texData.DataSize = newWidth * newHeight * 4;
+
+		oldView = interleaved_view(texData.Width, texData.Height, reinterpret_cast<const rgba8_ptr_t>(texData.Data.get()), texData.DataSize / texData.Height);
+
+		copy_pixels(view(newImage), oldView);	
+
+	}
+	else if (!strcmp(texData.Format, "bmp24"))
+	{
+		boost::shared_array<char> newData(new char [newWidth * newHeight * 3]);
+
+		rgb8_view_t oldView = interleaved_view(texData.Width, texData.Height, reinterpret_cast<const rgb8_ptr_t>(texData.Data.get()), texData.DataSize / texData.Height);
+
+		rgb8_image_t newImage(newWidth, newHeight);		
+
+		resize_view(oldView, view(newImage), bilinear_sampler());
+
+		texData.Data = newData;
+		texData.Width = newWidth;
+		texData.Height = newHeight;
+		texData.DataSize = newWidth * newHeight * 3;
+
+		oldView = interleaved_view(texData.Width, texData.Height, reinterpret_cast<const rgb8_ptr_t>(texData.Data.get()), texData.DataSize / texData.Height);
+
+		copy_pixels(view(newImage), oldView);	
+	}
+	else
+	{
+		throw ErrorToLog("TTextureListClass::NormalizeTexData Format unsupported: "+std::string(texData.Format));
+	}
+}
+
+
+bool TTextureListClass::CreateTexDataFromBmp24(const std::string& filename, TTextureData& texData)
+{
+
+	cardinal fileSize;
+	boost::shared_array<char> fileArr = CreateMemFromFile<char>(filename, fileSize);
+	
+	if (fileSize<22)
+		throw ErrorFileNotCorrect(filename);
+
+	//This refers to BITMAPV5HEADER
+
+	strcpy(texData.Format, "bmp24");
+	texData.Width = *reinterpret_cast<cardinal*>(&fileArr[18]);
+	texData.Height = *reinterpret_cast<cardinal*>(&fileArr[22]);
+	
+	texData.DataSize = texData.Height * texData.Width * 3;
+
+	texData.Data = boost::shared_array<char>(new char [texData.DataSize]);
+	
+	cardinal pos = *reinterpret_cast<cardinal*>(&fileArr[10]);
+	cardinal x = 0;
+
+	for (cardinal i=0; i<texData.Width; i++)
+		for(cardinal j=0; j<texData.Height; j++)
+		{
+				
+			if (pos+3>fileSize)
+				throw ErrorFileTooShort(filename);
+
+			x = (i * texData.Height + j) + (i * texData.Height + j) + (i * texData.Height + j);
+	
+			texData.Data[x + 2] = fileArr[pos++];
+			texData.Data[x + 1] = fileArr[pos++];
+			texData.Data[x + 0] = fileArr[pos++];
+		
+		}
+
+	return true;
+}
+
+
+bool TTextureListClass::CreateTexDataFromBmp32(const std::string& filename, TTextureData& texData)
+{
+	cardinal fileSize;
+	
+	boost::shared_array<char> fileArr = CreateMemFromFile<char>(filename, fileSize);
+
+	if (fileSize<22)
+		throw ErrorFileNotCorrect(filename);
+
+	//Meaning BITMAPV5HEADER
+
+	strcpy(texData.Format, "bmp32");
+	texData.Width = *reinterpret_cast<cardinal*>(&fileArr[18]);
+	texData.Height = *reinterpret_cast<cardinal*>(&fileArr[22]);
+
+	texData.DataSize = texData.Height * texData.Width * 4;
+
+	texData.Data = boost::shared_array<char>(new char [texData.DataSize]);
+
+	cardinal pos = *reinterpret_cast<cardinal*>(&fileArr[10]);
+	cardinal x = 0;
+
+	for (cardinal i=0; i<texData.Width; i++)
+		for(cardinal j=0; j<texData.Height; j++)
+		{
+				
+			if (pos+4>fileSize)
+				throw ErrorFileTooShort(filename);
+
+			x = (i * texData.Height + j) * 4;
+			texData.Data[x + 2] = fileArr[pos++];
+			texData.Data[x + 1] = fileArr[pos++];
+			texData.Data[x + 0] = fileArr[pos++];
+            texData.Data[x + 3] = fileArr[pos++];
+		}
+
+	//delete [] fileArr;
+
+	return true;
+}
+
+bool TTextureListClass::CreateTexDataFromTga(const std::string& filename, TTextureData& texData)
+{
+
+	cardinal fileSize;
+	boost::shared_array<char> fileArr = CreateMemFromFile<char>(filename, fileSize);
+
+	if (fileSize < 22)
+		throw ErrorFileNotCorrect(filename);
+
+	texData.Width = *reinterpret_cast<unsigned short int*>(&fileArr[12]);
+	texData.Height = *reinterpret_cast<unsigned short int*>(&fileArr[14]);
+
+	char textLength = fileArr[0];
+
+	char dataType = fileArr[2];
+
+	char bitsPerPixel = fileArr[16];
+
+
+	if (bitsPerPixel == 24)
+	{
+		texData.DataSize = texData.Height * texData.Width * 3;
+		texData.Data = boost::shared_array<char>(new char [texData.DataSize]);
+		strcpy(texData.Format, "bmp24");
+	}
+	else
+	if (bitsPerPixel == 32)
+	{
+		texData.DataSize = texData.Height * texData.Width * 4;
+		texData.Data = boost::shared_array<char>(new char [texData.DataSize]);
+		strcpy(texData.Format, "bmp32");
+	}
+	else
+		throw ErrorFileNotCorrect(filename);
+
+	int bytesPerPixel = bitsPerPixel / 8;
+
+	unsigned char blockInfo;
+	char whatItIs;
+	unsigned int numPixels;
+
+	cardinal n = 0;
+	int filePos = textLength + 18;
+
+	if (dataType == 2)
+	{
+		
+		for(cardinal n = 0; n < texData.Height * texData.Width; n++)
+		{
+			texData.Data[n*bytesPerPixel + 2] = fileArr[filePos++];
+			texData.Data[n*bytesPerPixel + 1] = fileArr[filePos++];
+			texData.Data[n*bytesPerPixel + 0] = fileArr[filePos++];
+			if (bitsPerPixel == 32)
+			{
+				texData.Data[n*bytesPerPixel + 3] = fileArr[filePos++];
+			}
+		}
+
+	}
+	else if (dataType == 10)
+	{
+		throw ErrorToLog("RLE-compressed TGA is not supported yet: "+filename);
+
+		while (n < texData.Height * texData.Width)
+		{
+			blockInfo = fileArr[filePos++];
+			whatItIs = blockInfo & 128;
+			numPixels = blockInfo & 127;
+			
+			if (whatItIs)
+			{
+				
+				for (cardinal i=0; i<numPixels; i++)
+				{
+					texData.Data[n*bytesPerPixel + 0] = fileArr[filePos + 0];
+					texData.Data[n*bytesPerPixel + 1] = fileArr[filePos + 1];
+					texData.Data[n*bytesPerPixel + 2] = fileArr[filePos + 2];
+					if (bitsPerPixel == 32)
+					{
+						texData.Data[n*bytesPerPixel + 3] = fileArr[filePos + 3];
+					}
+					n++;
+				}
+
+				if (bitsPerPixel == 32)
+				{
+					filePos += 4;
+				}
+				else
+				{
+					filePos += 3;
+				}
+
+				
+			}
+			else
+			{
+				
+				for (cardinal i=0; i<numPixels; i++)
+				{
+					texData.Data[n*bytesPerPixel + 0] = fileArr[filePos++];
+					texData.Data[n*bytesPerPixel + 1] = fileArr[filePos++];
+					texData.Data[n*bytesPerPixel + 2] = fileArr[filePos++];
+					if (bitsPerPixel == 32)
+					{
+						texData.Data[n*bytesPerPixel + 3] = fileArr[filePos++];
+					}
+					n++;
+				}
+			}
+
+		}
+	}
+	else
+		throw ErrorFileNotCorrect(filename);
+
+	return true;
+}
+
+
+bool TTextureListClass::CreateTexDataFromPng(const std::string& filename, TTextureData& texData)
+{
+	cardinal fileSize;
+	boost::shared_array<char> fileArr = CreateMemFromFile<char>(filename, fileSize);
+
+	if (fileSize < 22)
+		throw ErrorFileNotCorrect(filename);
+
+	TPngDataStruct s = read_png_file(fileArr, fileSize);
+
+	texData.Width = s.Width;
+	texData.Height = s.Height;
+
+	cardinal bytesPerPixel;
+
+	if (s.ColorType == PNG_COLOR_TYPE_RGB)
+	{
+		strcpy(texData.Format, "bmp24");
+
+		bytesPerPixel = 3;
+	}
+	else if (s.ColorType == PNG_COLOR_TYPE_RGBA)
+	{
+		strcpy(texData.Format, "bmp32");
+
+		bytesPerPixel = 4;
+	}
+
+	texData.DataSize = texData.Height * texData.Width * bytesPerPixel;
+	texData.Data = boost::shared_array<char>(new char [texData.DataSize]);
+
+
+	cardinal x;
+
+	for (cardinal i=0; i<texData.Width; i++)
+	{
+		for(cardinal j=0; j<texData.Height; j++)
+		{
+
+			x = (i + (texData.Height - j - 1) * texData.Width) * bytesPerPixel;
+			texData.Data[x + 2] = s.RowPointers[j][bytesPerPixel*i + 2];
+			texData.Data[x + 1] = s.RowPointers[j][bytesPerPixel*i + 1];
+			texData.Data[x + 0] = s.RowPointers[j][bytesPerPixel*i + 0];
+
+			if (bytesPerPixel == 4)
+			{
+				texData.Data[x + 3] = s.RowPointers[j][bytesPerPixel*i + 3];
+			}
+		}
+	}
+
+	
+	for (int y=0; y<s.Height; y++)
+	{
+		free (s.RowPointers[y]);
+	}
+
+	free(s.RowPointers);
+
+	png_destroy_read_struct(&s.PngPtr, &s.InfoPtr,(png_infopp)0);
+
+	return true;
+
+
+}
+
+cardinal TTextureListClass::AddTextureBmp24Data(const TTextureData& texData)
+{
+
+
+	cardinal TexID = 0;
+
+	glGenTextures(1, &TexID);
+	if (TexID == 0)
+	{
+		throw ErrorToLog("glGenTextures did not work");
+	}
+
+    glBindTexture(GL_TEXTURE_2D, TexID);
+
+	
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    
+	#ifdef TARGET_WIN32
+    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
+    #endif
+
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texData.Width, texData.Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &texData.Data[0]);
+
+    return TexID;
+}
+
+cardinal TTextureListClass::AddTextureBmp32Data(const TTextureData& texData)
+{
+	cardinal TexID;
+	glGenTextures(1, &TexID);
+	if (TexID == 0)
+	{
+		throw ErrorToLog("glGenTextures did not work");
+	}
+
+    glBindTexture(GL_TEXTURE_2D, TexID);
+
+	
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+   
+    #ifdef TARGET_WIN32
+    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
+	#endif
+	
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texData.Width, texData.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &texData.Data[0]);
+
+    return TexID;
+}
+
+cardinal TTextureListClass::AddCubemapTextureBmp24Data(TTextureData* texData)
+{
+	cardinal TexID;
+	glGenTextures(1, &TexID);
+	glBindTexture(GL_TEXTURE_CUBE_MAP, TexID);
+	
+	#ifdef TARGET_WIN32
+		
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+	
+	#endif
+
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+0, 0, GL_RGB, texData[0].Width, texData[0].Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &(texData[0].Data[0]));
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+1, 0, GL_RGB, texData[1].Width, texData[1].Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &(texData[1].Data[0]));
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+2, 0, GL_RGB, texData[2].Width, texData[2].Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &(texData[2].Data[0]));
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+3, 0, GL_RGB, texData[3].Width, texData[3].Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &(texData[3].Data[0]));
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+4, 0, GL_RGB, texData[4].Width, texData[4].Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &(texData[4].Data[0]));
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+5, 0, GL_RGB, texData[5].Width, texData[5].Height, 0, GL_RGB, GL_UNSIGNED_BYTE, &(texData[5].Data[0]));
+
+    return TexID;
+}
+
+cardinal TTextureListClass::GetTextureHeight(const std::string& texName)
+{
+	if (TexMap.count(texName) != 0)
+			return TexMap[texName].Height;
+		else
+			return 0;
+}
+
+cardinal TTextureListClass::GetTextureWidth(const std::string& texName)
+{
+	if (TexMap.count(texName) != 0)
+			return TexMap[texName].Width;
+		else
+			return 0;
+}
+
+
+cardinal TTextureListClass::AddTextureDirectly(const std::string& filename, std::string texName)
+{
+
+	cardinal TexID;
+
+	if (texName == "")
+	{
+		texName = GetFileName(filename);
+	}
+
+	//Basically:
+	if (filename == "")
+		return 0;
+
+	if (TexMap.count(texName) == 0)
+	{
+		std::string texext = GetFileExt(filename);
+        
+        TTextureData texData;
+        if (CreateFunctionMap[texext](filename,texData))
+        {
+            
+            NormalizeTexData(texData);
+            TexID = AddFunctionMap[std::string(texData.Format)](texData);
+            
+            if (TexID != 0)
+            {
+                *Console<<"ResourceManager::TexList Texture added: "+texName+" with id = "+tostr(TexID);
+                TexMap[texName].RefCount = 1;
+                TexMap[texName].TexID = TexID;
+                TexMap[texName].Width = texData.Width;
+                TexMap[texName].Height = texData.Height;
+            }
+            else
+                *Console<<"ResourceManager::TexList ERROR - TEXTURE ADD TO OPENGL FAILED: "+texName;
+        }
+        else
+        {
+            TexID = 0;
+            *Console<<"ResourceManager::TexList ERROR - TEXTURE LOAD FAILED: "+texName;
+            
+        }
+        
+        return TexID;
+        
+	}
+	else
+	{
+		++TexMap[texName].RefCount;
+		*Console<<"ResourceManager::TexList Texture reference added: "+texName;
+		return TexMap[texName].TexID;
+	}
+
+}
+
+cardinal TTextureListClass::AddTexture(const std::string& fileName, std::string texName)
+{
+
+    std::string fullFileName = ResourceManager->PathToResources + fileName;
+	return AddTextureDirectly(fullFileName, texName);
+    
+}
+
+
+cardinal TTextureListClass::AddTextureFromUserdata(const std::string& fileName, std::string texName)
+{
+	
+
+	if (!IsFileExistsInUserData(fileName))
+	{
+		throw ErrorToLog("File not found in userdata: "+fileName);
+	}
+
+	std::string fullFileName = GetFilePathUserData(fileName);
+
+	return AddTextureDirectly(fullFileName.c_str(), texName);
+}
+
+
+cardinal TTextureListClass::AddCubemapTexture(std::string filename[6])
+{
+
+	
+	filename[0] = ResourceManager->PathToResources + filename[0];
+	filename[1] = ResourceManager->PathToResources + filename[1];
+	filename[2] = ResourceManager->PathToResources + filename[2];
+	filename[3] = ResourceManager->PathToResources + filename[3];
+	filename[4] = ResourceManager->PathToResources + filename[4];
+	filename[5] = ResourceManager->PathToResources + filename[5];
+
+	std::string texname = GetFileName(filename[0]);
+	std::string texext;
+	cardinal TexID;
+	int i;
+
+	if (TexMap.count(texname) == 0)
+	{
+		TTextureData texData[6];
+		
+		for (i = 0; i < 6; i++)
+		{
+			texext = GetFileExt(filename[i]);
+			*Console<<"Going to add texture: "+filename[i];
+			if (texext == ".bmp")
+			{
+				if (!CreateTexDataFromBmp24(filename[i],texData[i]))
+				{
+					*Console<<"ResourceManager::TexList ERROR - TEXTURE LOAD FAILED: "+texname;
+					return 0;
+				}
+	
+			}
+			else
+			{
+
+				*Console<<"ResourceManager::TexList ERROR - FORMAT NOT SUPPORTED: "+texext;
+				return 0;
+			}
+
+		}
+
+		//All textures have been inserted into texData[6], lets add them
+
+		TexID = AddCubemapTextureBmp24Data(texData);
+
+		//for (int j = 0; j < 6; j++) delete [] texData[j].Data;
+
+		if (TexID != 0)
+		{
+			TexMap[texname].RefCount = 1;
+			TexMap[texname].TexID = TexID;
+			*Console<<"ResourceManager::TexList texture added succesfuly: "+texname;
+			return TexID;
+		}
+		else
+		{
+			*Console<<"ResourceManager::TexList ERROR - TEXTURE ADD TO OPENGL FAILED: "+texname;
+			return 0;
+		}
+
+
+	}
+	else
+	{
+		++TexMap[texname].RefCount;
+		*Console<<"ResourceManager::TexList Texture reference added: "+texname;
+		return TexMap[texname].TexID;
+	}
+
+}
+
+cardinal TTextureListClass::AddEmptyTexture(const std::string& texName,cardinal width,cardinal height)
+{
+	cardinal texID;
+
+	if (TexMap.count(texName) == 0)
+	{
+
+		glGenTextures(1, &texID);
+		glBindTexture(GL_TEXTURE_2D, texID);
+		
+		
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		
+		#ifdef TARGET_WIN32
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		#endif
+		
+		#ifndef TARGET_WIN32 //TARGET_ANDROID or TARGET_IOS
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		#endif
+	
+		
+	}
+	else
+	{
+		TexMap[texName].RefCount++;
+		texID = TexMap[texName].TexID;
+	}
+
+	return texID;
+
+}
+
+
+cardinal TTextureListClass::AddEmptyCubemapTexture(const std::string& texName,cardinal width,cardinal height)
+{
+	cardinal texID;
+
+	if (TexMap.count(texName) == 0)
+	{
+
+		glGenTextures(1, &texID);
+		glBindTexture(GL_TEXTURE_CUBE_MAP, texID);
+
+		#ifdef TARGET_WIN32
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+		
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		
+ 
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+0, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+1, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+2, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+3, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+4, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+5, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+		#endif
+		
+		#ifndef TARGET_WIN32 //TARGET_IOS or TARGET_ANDROID
+	
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+0, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+1, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+2, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+3, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+4, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+5, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		
+		#endif
+	}
+	else
+	{
+		TexMap[texName].RefCount++;
+		texID = TexMap[texName].TexID;
+	}
+
+	return texID;
+}
+
+
+cardinal TTextureListClass::AddDepthTexture(const std::string& texName,cardinal width,cardinal height)
+{
+	#ifdef TARGET_WIN32
+	cardinal texID;
+
+	if (TexMap.count(texName) == 0)
+	{
+
+		glGenTextures(1, &texID);
+		glBindTexture(GL_TEXTURE_2D, texID);
+
+		
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+
+	}
+	else
+	{
+		TexMap[texName].RefCount++;
+		texID = TexMap[texName].TexID;
+	}
+
+	return texID;
+	#endif
+	
+	#ifdef TARGET_ANDROID
+	
+	throw ErrorToLog("Trying to create depth texture on Android!!!");
+	
+	return 0;
+	
+	#endif
+#ifdef TARGET_IOS
+	
+	throw ErrorToLog("Trying to create depth texture on iOS!!!");
+	
+	return 0;
+	
+#endif
+
+}
+
+void TTextureListClass::DeleteTexture(const std::string& texName)
+{
+	if (TexMap.count(texName) != 0)
+	{
+		--TexMap[texName].RefCount;
+		
+		if (TexMap[texName].RefCount == 0)
+		{
+			glDeleteTextures(1,&(TexMap[texName].TexID));
+			TexMap.erase(texName);
+			*Console<<"ResourceManager::TexList texture "+texName+" deleted";
+		}
+		else
+			*Console<<"ResourceManager::TexList texture "+texName+" reference deleted";
+	}
+}
+
+
+void TTextureListClass::DeleteTexture(cardinal texID)
+{
+	TTextureMap::iterator i = TexMap.begin();
+
+	while (i != TexMap.end())
+	{
+		if (i->second.TexID == texID)
+		{
+			(i->second.RefCount)--;
+		
+			if (i->second.RefCount == 0)
+			{
+				glDeleteTextures(1,&(i->second.TexID));
+				
+				*Console << "ResourceManager::TexList texture " + (i->first) + " deleted";
+				
+				TexMap.erase(i);
+			}
+			else
+				*Console<<"ResourceManager::TexList texture "+(i->first)+" reference deleted";
+
+			i = TexMap.end(); //to go out of loop
+
+		}
+		else
+		{
+			++i;
+		}
+
+	}
+
+}
+
+
+void TTextureListClass::PrintTextureList()
+{
+	TTextureMap::iterator i;
+
+	Console->PrintImmediate("======= Texture List ==========");
+
+	for (i = TexMap.begin(); i != TexMap.end(); ++i)
+	{
+		Console->PrintImmediate("ID="+tostr(i->second.TexID) + " " + i->first +" Ref="+tostr(i->second.RefCount));
+	}
+}
+
+
+void TTextureListClass::BindFunctions()
+{
+	//*Console<<"Bind functions in TTextureListClass\n";
+	ResourceManager->ScriptManager.AddFunction("ptl", TScriptInfo("PrintTextureList"), *this, &TTextureListClass::PrintTextureList);
+}
+
+void TTextureListClass::SaveTexDataToPlainBmpToUserData(const std::string& fileName, TTextureData texData)
+{
+
+	std::string fullFileName = GetFilePathUserData(fileName);
+	FILE * pFile;
+	pFile = fopen (fullFileName.c_str(), "wb");
+
+	if (pFile == NULL)
+	{
+		throw ErrorToLog("pFile == NULL in TTextureListClass::SaveTexDataToPlainBmp");
+	}
+
+	char DummyBuffer[10];
+
+	fwrite (DummyBuffer, 1, 10, pFile); //0 -> 10
+
+	int rgbDataOffset = 26;
+
+	fwrite (&rgbDataOffset, 4, 1, pFile); //10 -> 14
+
+	fwrite (DummyBuffer, 1, 4, pFile); //14 -> 18
+
+	fwrite (&(texData.Width), 4, 1, pFile); //18 -> 22
+	fwrite (&(texData.Height), 4, 1, pFile); //22 -> 26
+
+	cardinal x = 0;
+
+	for (cardinal i = 0; i < texData.Width; i++)
+	{
+		for(cardinal j = 0; j < texData.Height; j++)
+		{
+			x = (i * texData.Height + j) + (i * texData.Height + j) + (i * texData.Height + j);
+
+			fwrite (&(texData.Data[x + 2]), 1, 1, pFile);
+			fwrite (&(texData.Data[x + 1]), 1, 1, pFile);
+			fwrite (&(texData.Data[x + 0]), 1, 1, pFile);
+		}
+	}
+
+	fclose (pFile);
+	
+}
+
+
+} //namespace SE

src/Utils/Console/Console.cpp

@@ -0,0 +1,243 @@
+#include "include/Engine.h"
+#include "boost/date_time.hpp"
+
+namespace SE
+{
+
+const cardinal CONST_MAX_ROWS_IN_HISTORY = 20;
+
+const float CONST_CONSOLE_PART_OF_SCREEN = 0.35f;
+
+const int CONST_ROW_WIDTH = 14;
+
+const std::string CONST_CONSOLE_TEX_NAME = "console_bkg.bmp";
+
+void TSimpleConsole::Draw()
+{
+
+
+	RenderUniform1f("Transparency", 1.f);
+
+	if (HistoryTriangeList.get() == 0)
+	{
+		HistoryTriangeList = std::shared_ptr<TTriangleList>(new TTriangleList);
+	}
+
+	float screenWidth = Renderer->GetMatrixWidth();
+	float screenHeight = Renderer->GetMatrixHeight();
+	glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[CONST_CONSOLE_TEX_NAME]);
+	
+	Renderer->PushProjectionMatrix(static_cast<float>(screenWidth), static_cast<float>(screenHeight));
+	Renderer->PushMatrix();
+	Renderer->LoadIdentity();
+
+	Renderer->DrawRect(vec2(0.f, screenHeight*(1.f - CONST_CONSOLE_PART_OF_SCREEN)), vec2(screenWidth, screenHeight));
+	
+	if (TextSavedInTriangleList != History)
+	{
+		TextSavedInTriangleList = History;
+		*HistoryTriangeList = ResourceManager->FontManager.DrawTextInBoxToVBO(vec2(0.f, screenHeight * (1.f - CONST_CONSOLE_PART_OF_SCREEN)), vec2(static_cast<float>(screenWidth), static_cast<float>(screenHeight)), CONST_ROW_WIDTH, TextSavedInTriangleList);
+	}
+
+	TTriangleList consoleInputTriangleList = ResourceManager->FontManager.DrawTextInBoxToVBO(vec2(0.f, screenHeight * (1.f - CONST_CONSOLE_PART_OF_SCREEN)), vec2(static_cast<float>(screenWidth), static_cast<float>(screenHeight)), CONST_ROW_WIDTH, ">"+ConsoleInput);
+
+	glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList[ResourceManager->FontManager.GetCurrentFontTextureName()]);
+
+	Renderer->DrawTriangleList(*HistoryTriangeList);
+	Renderer->DrawTriangleList(consoleInputTriangleList);
+
+	std::string ConsoleInputAtCursor = std::string((">"+ConsoleInput), 0, ConsoleCursor+1);
+
+	float advance = ResourceManager->FontManager.GetTextAdvance(ConsoleInputAtCursor);
+
+	TTriangleList consoleCursorTriangleList = ResourceManager->FontManager.DrawTextInBoxToVBO(vec2(advance, screenHeight*(1.f - CONST_CONSOLE_PART_OF_SCREEN)), vec2(static_cast<float>(screenWidth), static_cast<float>(screenHeight)), 14, "|");
+
+	Renderer->DrawTriangleList(consoleCursorTriangleList);
+	
+	Renderer->PopMatrix();
+	Renderer->PopProjectionMatrix();
+
+}
+
+
+void TSimpleConsole::CutHistory()
+{
+	cardinal i = 0;
+
+	cardinal pos = std::string::npos;
+	
+	do
+	{
+		if (pos != std::string::npos && pos > 0)
+		{
+			pos--;
+		}
+
+		pos = History.find_last_of('\n', pos);
+		i++;
+	}
+	while (pos != std::string::npos && i != CONST_MAX_ROWS_IN_HISTORY);
+
+	if (pos != std::string::npos)
+	{
+		History = History.substr(pos);
+	}
+}
+
+std::string TSimpleConsole::GetHistory()
+{
+	return History;
+}
+
+
+#ifdef TARGET_WIN32
+
+TFileConsole::TFileConsole() 
+	: filename("conlog.txt")
+	, f("conlog.txt") 
+{
+}
+
+TFileConsole::TFileConsole(const std::string& Afilename) 
+	: filename(Afilename)
+	, f(Afilename) 
+{
+}
+
+TFileConsole::~TFileConsole() 
+{
+	f.close();
+}
+
+TFileConsole& TFileConsole::operator<<(const std::string& s) 
+{
+	boost::posix_time::ptime t = boost::posix_time::second_clock::local_time();
+	
+	std::string string_with_time_mark;
+
+	string_with_time_mark = to_simple_string(t)+": "+s;
+
+	PrintImmediate(string_with_time_mark);
+
+	History += string_with_time_mark+endl;
+	CutHistory();
+
+	return *this;
+}
+
+
+void TFileConsole::PrintImmediate(const std::string& s)
+{
+    
+	f<<s+endl;
+	f.flush();
+
+	OutputDebugString( (s+endl).c_str() ); 
+    
+}
+
+
+
+#endif
+
+
+#ifdef TARGET_ANDROID
+
+#include "include/Utils/JniApi/JniApi.h"
+
+TJavaConsole::TJavaConsole()
+{
+	boost::mutex::scoped_lock scoped_lock(ConsoleMutex);
+
+    AppDir = JniGetApplicationDir();
+    LogFilename = AppDir + "/fishrungames-log.txt";
+
+	FILE* file = fopen(LogFilename.c_str(), "w");
+		
+	if (file != NULL)
+	{
+		fclose(file);
+	}
+}
+
+TJavaConsole& TJavaConsole::operator<<(const std::string& s) 
+{ 
+    boost::mutex::scoped_lock scoped_lock(ConsoleMutex);
+
+	boost::posix_time::ptime t = boost::posix_time::second_clock::local_time();
+	
+	std::string string_with_time_mark;
+
+	string_with_time_mark = boost::posix_time::to_simple_string(t)+": "+s;
+
+    PrintImmediate(string_with_time_mark);
+
+	History += string_with_time_mark+endl;
+	CutHistory();
+	
+
+	return *this; 
+}
+
+
+void TJavaConsole::PrintImmediate(const std::string& s)
+{
+    
+	FILE* file = fopen(LogFilename.c_str(), "a");
+    
+	if (file != NULL)
+	{
+		fputs(std::string(s+endl).c_str(), file);
+		fflush(file);
+		fclose(file);
+	}
+    
+}
+
+
+#endif
+
+
+#ifdef TARGET_IOS
+
+TIosConsole::TIosConsole() 
+{
+}
+
+
+
+TIosConsole::~TIosConsole() 
+{
+
+}
+
+TIosConsole& TIosConsole::operator<<(const std::string& s) 
+{
+	boost::posix_time::ptime t = boost::posix_time::second_clock::local_time();
+	
+	std::string string_with_time_mark;
+    
+	string_with_time_mark = to_simple_string(t)+": "+s;
+    
+	PrintImmediate(string_with_time_mark);
+    
+	History += string_with_time_mark+endl;
+	CutHistory();
+    
+	return *this;
+}
+
+void TIosConsole::PrintImmediate(const std::string& s)
+{
+    printf("%s", std::string(s+endl).c_str());
+    
+}
+
+
+#endif
+
+
+} //namespace SE
+
+
+

src/Utils/DataTypes/DataTypes.cpp

@@ -0,0 +1,479 @@
+#include "include/Utils/DataTypes/DataTypes.h"
+#include "include/Utils/ErrorTypes/ErrorTypes.h"
+
+#include "boost/algorithm/string.hpp"
+namespace SE
+{
+
+mat4 InverseModelViewMatrix(const mat4& m)
+{
+	mat4 r;
+	r.m[0] = m.m[0];
+	r.m[1] = m.m[4];
+	r.m[2] = m.m[8];
+	r.m[3] = 0.0f;
+	r.m[4] = m.m[1];
+	r.m[5] = m.m[5];
+	r.m[6] = m.m[9];
+	r.m[7] = 0.0f;
+	r.m[8] = m.m[2];
+	r.m[9] = m.m[6];
+	r.m[10] = m.m[10];
+	r.m[11] = 0.0f;
+
+	r.m[12] = - (m.m[12]*r.m[0] + m.m[13]*r.m[4] + m.m[14]*r.m[8]);
+	r.m[13] = - (m.m[12]*r.m[1] + m.m[13]*r.m[5] + m.m[14]*r.m[9]);
+	r.m[14] = - (m.m[12]*r.m[2] + m.m[13]*r.m[6] + m.m[14]*r.m[10]);
+	r.m[15] = 1.0f;
+
+	return r;
+
+}
+
+
+
+mat4 SetToNormalMatrix(const mat4& m)
+{
+	mat4 r;
+	r.m[0] = m.m[0];
+	r.m[1] = m.m[4];
+	r.m[2] = m.m[8];
+	r.m[3] = 0.0f;
+	r.m[4] = m.m[1];
+	r.m[5] = m.m[5];
+	r.m[6] = m.m[9];
+	r.m[7] = 0.0f;
+	r.m[8] = m.m[2];
+	r.m[9] = m.m[6];
+	r.m[10] = m.m[10];
+	r.m[11] = 0.0f;
+
+	r.m[12] = 0.0f;
+	r.m[13] = 0.0f;
+	r.m[14] = 0.0f;
+	r.m[15] = 1.0f;
+
+	return r;
+}
+
+mat4 MakeOrthoMatrix(float width, float height)
+{
+	mat4 r;
+	r.m[0] = 2.f / width;
+	r.m[1] = 0;
+	r.m[2] = 0;
+	r.m[3] = 0;
+	
+	r.m[4] = 0;
+	r.m[5] = 2.f / height;
+	r.m[6] = 0;
+	r.m[7] = 0;
+	
+	r.m[8] = 0;
+	r.m[9] = 0;
+	r.m[10] = -1;
+	r.m[11] = 0;
+	
+	r.m[12] = -1;
+	r.m[13] = -1;
+	r.m[14] = 0;
+	r.m[15] = 1;
+	
+	return r;
+}
+
+mat4 MakeFrustumMatrix(float left, float right, float bottom, float top, float nearVal, float farVal)
+{
+	mat4 r;
+
+	float a = (right + left) / (right - left);
+	
+	float b = (top + bottom) / (top - bottom);
+
+	float c = - (farVal + nearVal) / (farVal - nearVal);
+
+	float d = - (2.f * farVal * nearVal) / (farVal - nearVal);
+
+
+	r.m[0] = 2.f*nearVal / (right - left); r.m[4] = 0.f; r.m[8] = a; r.m[12] = 0.f;
+	r.m[1] = 0.f; r.m[5] = 2.f*nearVal / (top - bottom); r.m[9] = b; r.m[13] = 0.f;
+	r.m[2] = 0.f; r.m[6] = 0.f; r.m[10] = c; r.m[14] = d;
+	r.m[3] = 0.f; r.m[7] = 0.f; r.m[11] = -1; r.m[15] = 0.f;
+	
+	return r;
+}
+
+mat4 MakePerspectiveMatrix(float angle, float aspect, float zNear, float zFar)
+{
+	//angle = angle * pi / 180.f;
+
+	float top = zNear * tan(angle / 2.f);
+	float bottom = -top;
+
+	float left = bottom * aspect;
+	float right = top * aspect;
+	
+
+	return MakeFrustumMatrix(left, right, bottom, top, zNear, zFar);
+}
+
+mat4 MultMatrixMatrix(const mat4& m1, const mat4& m2)
+{
+    mat4 r;
+
+	r.m[0] = m1.m[0]*m2.m[0] + m1.m[4]*m2.m[1] + m1.m[8]*m2.m[2] + m1.m[12]*m2.m[3];
+	r.m[1] = m1.m[1]*m2.m[0] + m1.m[5]*m2.m[1] + m1.m[9]*m2.m[2] + m1.m[13]*m2.m[3];
+	r.m[2] = m1.m[2]*m2.m[0] + m1.m[6]*m2.m[1] + m1.m[10]*m2.m[2] + m1.m[14]*m2.m[3];
+	r.m[3] = m1.m[3]*m2.m[0] + m1.m[7]*m2.m[1] + m1.m[11]*m2.m[2] + m1.m[15]*m2.m[3];
+
+	r.m[4] = m1.m[0]*m2.m[4] + m1.m[4]*m2.m[5] + m1.m[8]*m2.m[6] + m1.m[12]*m2.m[7];
+	r.m[5] = m1.m[1]*m2.m[4] + m1.m[5]*m2.m[5] + m1.m[9]*m2.m[6] + m1.m[13]*m2.m[7];
+	r.m[6] = m1.m[2]*m2.m[4] + m1.m[6]*m2.m[5] + m1.m[10]*m2.m[6] + m1.m[14]*m2.m[7];
+	r.m[7] = m1.m[3]*m2.m[4] + m1.m[7]*m2.m[5] + m1.m[11]*m2.m[6] + m1.m[15]*m2.m[7];
+
+
+	r.m[8] = m1.m[0]*m2.m[8] + m1.m[4]*m2.m[9] + m1.m[8]*m2.m[10] + m1.m[12]*m2.m[11];
+	r.m[9] = m1.m[1]*m2.m[8] + m1.m[5]*m2.m[9] + m1.m[9]*m2.m[10] + m1.m[13]*m2.m[11];
+	r.m[10] = m1.m[2]*m2.m[8] + m1.m[6]*m2.m[9] + m1.m[10]*m2.m[10] + m1.m[14]*m2.m[11];
+	r.m[11] = m1.m[3]*m2.m[8] + m1.m[7]*m2.m[9] + m1.m[11]*m2.m[10] + m1.m[15]*m2.m[11];
+	
+	r.m[12] = m1.m[0]*m2.m[12] + m1.m[4]*m2.m[13] + m1.m[8]*m2.m[14] + m1.m[12]*m2.m[15];
+	r.m[13] = m1.m[1]*m2.m[12] + m1.m[5]*m2.m[13] + m1.m[9]*m2.m[14] + m1.m[13]*m2.m[15];
+	r.m[14] = m1.m[2]*m2.m[12] + m1.m[6]*m2.m[13] + m1.m[10]*m2.m[14] + m1.m[14]*m2.m[15];
+	r.m[15] = m1.m[3]*m2.m[12] + m1.m[7]*m2.m[13] + m1.m[11]*m2.m[14] + m1.m[15]*m2.m[15];
+
+    return r;
+}
+
+
+bool IsFloatEqual(float a, float b)
+{
+	return (fabs(b-a) <= CONST_EPSILON) ? true : false;
+}
+
+
+int LineCrossTriangle(const vec3& a, const vec3& b, const TSmpTriangle& tr)
+{
+	vec3 dummy;
+	return LineCrossTriangle(a, b, tr, dummy);
+}
+
+
+int LineCrossTriangle(const vec3& a, const vec3& b, const TSmpTriangle& tr, vec3& CrossPoint)
+{
+
+	vec3 h, q, t, vx;
+	mat3 M;
+
+	h = b - a;
+
+	if (IsFloatEqual(DotProduct(tr.n, h), 0.0f))
+	{
+		return -1;
+	}
+
+	M.m[0] = h.v[0];
+	M.m[3] = h.v[1];
+	M.m[6] = h.v[2];
+
+	M.m[1] = -tr.v.v[0];
+	M.m[4] = -tr.v.v[1];
+	M.m[7] = -tr.v.v[2];
+
+	M.m[2] = -tr.w.v[0];
+	M.m[5] = -tr.w.v[1];
+	M.m[8] = -tr.w.v[2];
+
+	M = InverseMatrix(M);
+
+	vx = tr.p[0] - a;
+
+	t = vx * M;
+
+	if ((t.v[0]<0)||(t.v[0]>1))
+	{
+		return 0;
+	}
+
+	q = a + h * t.v[0];
+	
+	CrossPoint = q;
+
+	return PointInTriangle(q, tr);
+
+
+}
+
+int PointInTriangle(const vec3& q, const TSmpTriangle& tr)
+{
+	vec3 v,h;
+	float nf2[3];
+	vec4 quat, inv_quat, p;
+
+	TSmpTriangle trx;
+
+	float sina,cosa,cos2a;
+
+	int i;
+
+	h = vec3(0.0f, 1.0f, 0.0f);
+	
+
+	if (IsFloatEqual(tr.n.v[0],0.0f) && (!IsFloatEqual(tr.n.v[1],0.0f)) && IsFloatEqual(tr.n.v[2],0.0f))
+	{
+		quat = vec4(1.0f, 0.0f, 0.0f, 0.0f);
+	}
+	else
+	{
+		v = CrossProduct(tr.n,h);
+
+		cos2a = DotProduct(Normalize(tr.n), h);
+
+		cos2a *= 0.5f;
+		cosa = sqrtf(0.5f + cos2a);
+		sina = sqrtf(0.5f - cos2a);
+
+		v = Normalize(v);
+
+		quat.v[0] = v.v[0]*sina;
+		quat.v[1] = v.v[1]*sina;
+		quat.v[2] = v.v[2]*sina;
+		quat.v[3] = cosa;
+
+	}
+
+	inv_quat.v[0] = - quat.v[0];
+	inv_quat.v[1] = - quat.v[1];
+	inv_quat.v[2] = - quat.v[2];
+	inv_quat.v[3] = quat.v[3];
+
+	for (i=0; i<3; i++)
+	{
+		p = vec4(tr.p[i]);
+
+		p = quat * p * inv_quat;
+
+		trx.p[i] = vec3(p);
+		
+	};
+
+	p.v[0] = q.v[0];
+	p.v[1] = q.v[1];
+	p.v[2] = q.v[2];
+	p.v[3] = 0.0f;
+
+	p = quat * p * inv_quat;
+
+
+	for (i=0;i<2;i++)
+		nf2[i] = (p.v[0]-trx.p[i].v[0])*(trx.p[i+1].v[2]-trx.p[i].v[2])-(p.v[2]-trx.p[i].v[2])*(trx.p[i+1].v[0]-trx.p[i].v[0]);
+
+	//Not to go over array:
+	nf2[2] = (p.v[0]-trx.p[2].v[0])*(trx.p[0].v[2]-trx.p[2].v[2])-(p.v[2]-trx.p[2].v[2])*(trx.p[0].v[0]-trx.p[2].v[0]);
+
+	if (((nf2[0]>=0.0f) && (nf2[1]>=0.0f) && (nf2[2]>=0.0f))
+		|| ((nf2[0]<=0.0f) && (nf2[1]<=0.0f) && (nf2[2]<=0.0f)))
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+	
+}
+
+
+float roundf(float r)
+{
+	return (r > 0.0f) ? floorf(r + 0.5f) : ceilf(r - 0.5f); 
+} 
+
+cardinal GetGreaterPower2(cardinal x)
+{
+	if (x > 65536)
+	{
+		throw ErrorToLog("GetGreaterPower2: x("+tostr(x)+") is bigger than 65536");
+	}
+
+	cardinal result = 1;
+
+	while (x > result)
+	{
+		result *= 2;
+	}
+
+	return result;
+}
+
+vec2 StringToVec2(std::string str)
+{
+	boost::erase_all(str, " ");
+
+	std::vector<std::string> splitVec;
+
+	boost::split( splitVec, str, boost::is_any_of(",;"), boost::token_compress_on );
+
+	if (splitVec.size() < 2)
+	{
+		throw ErrorToLog("StringToVec2 - vector is too short: "+str);
+	}
+
+	vec2 result;
+
+	result.v[0] = boost::lexical_cast<float>(splitVec[0]);
+	result.v[1] = boost::lexical_cast<float>(splitVec[1]);
+
+	return result;
+}
+
+vec3 StringToVec3(std::string str)
+{
+	boost::erase_all(str, " ");
+
+	std::vector<std::string> splitVec;
+
+	boost::split( splitVec, str, boost::is_any_of(",;"), boost::token_compress_on );
+
+	if (splitVec.size() < 3)
+	{
+		throw ErrorToLog("StringToVec3 - vector is too short: "+str);
+	}
+
+	vec3 result;
+
+	result.v[0] = boost::lexical_cast<float>(splitVec[0]);
+	result.v[1] = boost::lexical_cast<float>(splitVec[1]);
+	result.v[2] = boost::lexical_cast<float>(splitVec[2]);
+
+	return result;
+}
+
+vec4 StringToVec4(std::string str)
+{
+	boost::erase_all(str, " ");
+
+	std::vector<std::string> splitVec;
+
+	boost::split( splitVec, str, boost::is_any_of(",;"), boost::token_compress_on );
+
+	if (splitVec.size() < 4)
+	{
+		throw ErrorToLog("StringToVec4 - vector is too short: "+str);
+	}
+
+	vec4 result;
+
+	result.v[0] = boost::lexical_cast<float>(splitVec[0]);
+	result.v[1] = boost::lexical_cast<float>(splitVec[1]);
+	result.v[2] = boost::lexical_cast<float>(splitVec[2]);
+	result.v[3] = boost::lexical_cast<float>(splitVec[3]);
+
+	return result;
+}
+
+
+// ================================================
+// ========== wide strings and UTF8 strings =======
+// ================================================
+
+
+void utf8toWStr(std::wstring& dest, const std::string& src){
+	dest.clear();
+	wchar_t w = 0;
+	int bytes = 0;
+	wchar_t err = 0xFFFD;
+	for (size_t i = 0; i < src.size(); i++){
+		unsigned char c = (unsigned char)src[i];
+		if (c <= 0x7f){//first byte
+			if (bytes){
+				dest.push_back(err);
+				bytes = 0;
+			}
+			dest.push_back((wchar_t)c);
+		}
+		else if (c <= 0xbf){//second/third/etc byte
+			if (bytes){
+				w = ((w << 6)|(c & 0x3f));
+				bytes--;
+				if (bytes == 0)
+					dest.push_back(w);
+			}
+			else
+				dest.push_back(err);
+		}
+		else if (c <= 0xdf){//2byte sequence start
+			bytes = 1;
+			w = c & 0x1f;
+		}
+		else if (c <= 0xef){//3byte sequence start
+			bytes = 2;
+			w = c & 0x0f;
+		}
+		else if (c <= 0xf7){//3byte sequence start
+			bytes = 3;
+			w = c & 0x07;
+		}
+		else{
+			dest.push_back(err);
+			bytes = 0;
+		}
+	}
+	if (bytes)
+		dest.push_back(err);
+}
+
+void wstrToUtf8(std::string& dest, const std::wstring& src){
+	dest.clear();
+	for (size_t i = 0; i < src.size(); i++){
+		wchar_t w = src[i];
+		if (w <= 0x7f)
+			dest.push_back((char)w);
+		else if (w <= 0x7ff){
+			dest.push_back(0xc0 | ((w >> 6)& 0x1f));
+			dest.push_back(0x80| (w & 0x3f));
+		}
+		else if (w <= 0xffff){
+			dest.push_back(0xe0 | ((w >> 12)& 0x0f));
+			dest.push_back(0x80| ((w >> 6) & 0x3f));
+			dest.push_back(0x80| (w & 0x3f));
+		}
+		else if (w <= 0x10ffff){
+			dest.push_back(0xf0 | ((w >> 18)& 0x07));
+			dest.push_back(0x80| ((w >> 12) & 0x3f));
+			dest.push_back(0x80| ((w >> 6) & 0x3f));
+			dest.push_back(0x80| (w & 0x3f));
+		}
+		else
+			dest.push_back('?');
+	}
+}
+
+std::string wstrToUtf8(const std::wstring& str){
+	std::string result;
+	wstrToUtf8(result, str);
+	return result;
+}
+
+std::wstring utf8toWStr(const std::string& str){
+	std::wstring result;
+	utf8toWStr(result, str);
+	return result;
+}
+
+std::ostream& operator<<(std::ostream& f, const std::wstring& s){
+	std::string s1;
+	wstrToUtf8(s1, s);
+	f << s1;
+	return f;
+}
+
+std::istream& operator>>(std::istream& f, std::wstring& s){
+	std::string s1;
+	f >> s1;
+	utf8toWStr(s, s1);
+	return f;
+}
+
+
+} //namespace SE

src/Utils/DataTypes/NewDataTypes.cpp

@@ -0,0 +1,57 @@
+#include "include/Utils/DataTypes/NewDataTypes.h"
+#include "include/Utils/DataTypes/DataTypes.h"
+#include "include/Utils/ErrorTypes/ErrorTypes.h"
+
+namespace SE
+{
+
+mat3 TransposeMatrix(const mat3& m)
+{
+	mat3 r;
+	r.m[0] = m.m[0];
+	r.m[1] = m.m[3];
+	r.m[2] = m.m[6];
+	r.m[3] = m.m[1];
+	r.m[4] = m.m[4];
+	r.m[5] = m.m[7];
+	r.m[6] = m.m[2];
+	r.m[7] = m.m[5];
+	r.m[8] = m.m[8];
+	return r;
+}
+
+mat3 InverseMatrix(const mat3& m)
+{
+	float d;
+	mat3 r;
+    
+	d = m.m[0]*(m.m[4]*m.m[8] - m.m[5]*m.m[7]);
+	d -= m.m[1]*(m.m[3]*m.m[8] - m.m[6]*m.m[5]);
+	d += m.m[2]*(m.m[3]*m.m[7] - m.m[6]*m.m[4]);
+    
+	if (IsFloatEqual(d,0.0f))
+	{
+		throw ErrorToLog("Error: matrix cannot be inversed!");
+        
+	}
+	else
+	{
+        
+        r.m[0] = (m.m[4]*m.m[8] - m.m[5]*m.m[7])/d;
+        r.m[1] = - (m.m[1]*m.m[8] - m.m[2]*m.m[7])/d;
+        r.m[2] = (m.m[1]*m.m[5] - m.m[2]*m.m[4])/d;
+        
+        r.m[3] = - (m.m[3]*m.m[8] - m.m[5]*m.m[6])/d;
+        r.m[4] = (m.m[0]*m.m[8] - m.m[2]*m.m[6])/d;
+        r.m[5] = - (m.m[0]*m.m[5] - m.m[2]*m.m[3])/d;
+        
+        r.m[6] = (m.m[3]*m.m[7] - m.m[6]*m.m[4])/d;
+        r.m[7] = - (m.m[0]*m.m[7] - m.m[6]*m.m[1])/d;
+        r.m[8] = (m.m[0]*m.m[4] - m.m[1]*m.m[3])/d;
+        
+	};
+	return r;
+}
+
+
+} //namespace SE

src/Utils/FileUtils/FileUtils.cpp

@@ -0,0 +1,91 @@
+#include "include/Utils/FileUtils/FileUtils.h"
+
+#include "include/Utils/Utils.h"
+
+#include "include/Engine.h"
+
+#include <string>
+
+namespace SE
+{
+
+bool findString(char* in, char* list)
+{
+  int thisLength = strlen(in);
+  while (*list != 0)
+  {
+    int length = strcspn(list," ");
+    
+    if( thisLength == length )
+      if (!strncmp(in,list,length))
+        return true;
+        
+    list += length + 1;
+  }
+  return false;
+}
+
+std::string GetFilePath(const std::string& filename)
+{
+	//any symbol - "/" or "\"
+	
+	int i = filename.find_last_of("/\\");
+
+	if (i==filename.npos)
+	{
+		return "";
+	}
+
+	std::string r = filename.substr(0, i+1);
+
+	return r;
+}
+
+
+bool IsFileExistsInUserData(const std::string& filename)
+{
+
+	std::string realFileName = GetFilePathUserData(filename);
+
+	FILE* f;
+
+	f = fopen(realFileName.c_str(), "r");
+	
+	if (f == NULL)
+	{
+		return false;
+	}
+	
+	fclose(f);
+	
+	return true;
+}
+
+
+
+std::string GetFilePathUserData(const std::string& filename)
+{
+#ifdef TARGET_WIN32
+	std::string realFileName = filename;
+#endif
+#ifdef TARGET_ANDROID
+	std::string realFileName = JniGetApplicationDir()+"/" + filename;
+#endif
+#ifdef TARGET_IOS
+	std::string realFileName = IosGetFilePathUserData(filename);
+#endif
+
+	return realFileName;
+}
+
+#ifdef TARGET_IOS
+//Special for IOS -> Foundation.h conflicts with sq_plus.h
+std::string GetPathToResources()
+{
+    return ResourceManager->PathToResources;
+}
+#endif
+
+
+
+} //namespace SE

src/Utils/IosApi/IosApi.mm

@@ -0,0 +1,51 @@
+//
+//  Halibut_Engine.m
+//  Halibut Engine
+//
+//  Created by vvv ооо on 13.07.12.
+//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+#include "include/Utils/Utils.h"
+
+
+namespace SE
+{
+
+std::string IosGetFileReadPath(const std::string& filename)
+{
+    
+    NSString* nsFullFileName = [NSString stringWithCString:filename.c_str() encoding:NSUTF8StringEncoding];
+    
+    NSString* nsFileShortName = [nsFullFileName lastPathComponent];
+    
+    NSString* nsFileShortNameWithoutExt = [nsFileShortName stringByDeletingPathExtension];
+    
+    NSString* nsFileExt = [nsFullFileName pathExtension];
+    
+    NSString* nsFilePath = [nsFullFileName stringByDeletingLastPathComponent];
+    
+    NSString *filePath = [[NSBundle mainBundle] pathForResource:nsFileShortNameWithoutExt ofType:nsFileExt inDirectory:nsFilePath];
+    
+    return std::string([filePath UTF8String]);
+}
+
+
+std::string IosGetFilePathUserData(const std::string& filename)
+{
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, 
+                                                         NSUserDomainMask, YES);
+    
+    
+    NSString* docDir = [paths objectAtIndex:0];
+    docDir = [docDir stringByAppendingString:@"/"];
+    
+    NSString* file = [docDir stringByAppendingString:[NSString stringWithCString:filename.c_str() encoding:NSUTF8StringEncoding]];
+    
+    return std::string([[NSFileManager defaultManager] fileSystemRepresentationWithPath:file]);
+}
+
+} //namespace SE
+

src/Utils/JniApi/JniApi.cpp

@@ -0,0 +1,389 @@
+#include "include/Utils/JniApi/JniApi.h"
+
+#include "include/Utils/Utils.h"
+
+namespace SE
+{
+
+JavaVM* JavaVirtualMachine = 0;
+
+const std::string CONST_JAVA_FILESYSTEM_CLASS_NAME = "fishrungames/engine/FileWrapper";
+
+//Private data
+
+//All 3 deprecated
+cardinal* FileArr = NULL;
+int FileSize = 0;
+int filePointer;
+
+std::string ApkFilePath;
+
+//Private methods
+jclass JniTryFindClass(const std::string& className);
+jmethodID JniTryFindStaticMethod(jclass clazz, const std::string& methodId, const std::string methodSignature);
+void CheckCommonExceptionWithMessage(const std::string& message);
+
+//Deprecated
+void JniCallOpenFile(const std::string& fileName);
+
+
+//==================================================
+//=============== IMPLEMENTATION ===================
+//==================================================
+
+
+JNIEXPORT void JNICALL Java_fishrungames_engine_FileWrapper_SetupEnviroment(JNIEnv* env, jobject thiz)
+{
+    int JVMResult;
+    JVMResult = env->GetJavaVM(&JavaVirtualMachine);
+    
+    //TODO: Check if jmvresult != 0
+}
+
+JNIEXPORT void JNICALL Java_fishrungames_engine_FileWrapper_SetupApkFilePath(JNIEnv* env, jobject thiz, jstring s)
+{
+
+	const char *nativeString = env->GetStringUTFChars(s, 0);
+	
+	ApkFilePath = std::string(nativeString);
+	
+   env->ReleaseStringUTFChars(s, nativeString);
+
+}
+
+JNIEXPORT void JNICALL Java_fishrungames_engine_FileWrapper_ConsoleOut(JNIEnv* env, jobject thiz, jstring s)
+{
+	const char *nativeString = env->GetStringUTFChars(s, 0);
+
+   *Console<<std::string("OUT OF JAVA: ")+nativeString;
+
+   env->ReleaseStringUTFChars(s, nativeString);
+
+}
+
+
+//Deprecated
+JNIEXPORT void JNICALL Java_fishrungames_engine_FileWrapper_CreateFile(JNIEnv* env, jobject thiz, int fileSize)
+{
+	FileSize = fileSize;
+	FileArr =  new cardinal [fileSize % 4 == 0 ? fileSize/4 : fileSize/4 + 1];
+	filePointer = 0;
+}
+	
+	
+//Deprecated
+JNIEXPORT void JNICALL Java_fishrungames_engine_FileWrapper_WriteToFile(JNIEnv* env, jobject thiz, jbyteArray buffer, int bufferSize)
+{
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+	jenv->GetByteArrayRegion(buffer, 0, bufferSize, (jbyte*)((char*)FileArr + filePointer));
+	filePointer += bufferSize;
+	
+}
+
+//===================================================
+//============== Private methods ====================
+//===================================================
+
+jclass JniTryFindClass(const std::string& className)
+{
+    
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+    
+	jclass clazz = jenv->FindClass(className.c_str());
+	
+	
+	if (jenv->ExceptionOccurred() != 0)
+	{
+		jenv->ExceptionClear();
+		throw ErrorToLog("JNI: failed to find class: "+className);
+	} 
+
+    return clazz;
+}
+
+jmethodID JniTryFindStaticMethod(jclass clazz, const std::string& methodId, const std::string methodSignature)
+{
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jmethodID mid = jenv->GetStaticMethodID(clazz, methodId.c_str(), methodSignature.c_str());
+	
+	if (jenv->ExceptionOccurred() != 0)
+	{
+		jenv->ExceptionClear(); 
+		throw ErrorToLog("JNI: failed to find static method: "+methodId+" with signature: "+methodSignature);
+	}
+	
+	return mid;
+}
+
+void CheckCommonExceptionWithMessage(const std::string& message)
+{
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+    
+	if (jenv->ExceptionOccurred() != 0)
+	{
+		jenv->ExceptionClear(); 
+		throw ErrorToLog(message);
+	}
+}
+
+
+//Deprecated
+void JniCallOpenFile(const std::string& fileName)
+{
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+	jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+
+    jmethodID mid = JniTryFindStaticMethod(clazz, "OpenFile", "(Ljava/lang/String;)I");
+
+	jstring jstr = jenv->NewStringUTF(fileName.c_str());
+
+
+	CheckCommonExceptionWithMessage("Fail in JniCallOpenFile\n");
+	
+	//Any problem? - see console log
+	if (jenv->CallStaticIntMethod(clazz, mid, jstr) != 1)
+		throw ErrorToLog("ERROR: Could not open file: " + fileName);
+}
+
+
+std::string JniGetApplicationDir()
+{
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "GetApplicationDir", "()Ljava/lang/String;");
+	
+	jstring jstr = (jstring)jenv->CallStaticObjectMethod(clazz, mid);
+	
+	const char *nativeString = jenv->GetStringUTFChars(jstr, 0);
+    
+    std::string s(nativeString);
+
+    jenv->ReleaseStringUTFChars(jstr, nativeString);
+    
+    return s;
+
+}
+
+
+void JniLoadSound(const std::string& fileName)
+{
+    
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "LoadSound", "(Ljava/lang/String;)V");
+	
+	jstring jstr = jenv->NewStringUTF(fileName.c_str());
+
+	CheckCommonExceptionWithMessage("Fail in JniLoadSound");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid, jstr);
+	
+}
+
+void JniPlaySound(const std::string& soundName)
+{
+    
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "PlaySound", "(Ljava/lang/String;)V");
+	
+	jstring jstr = jenv->NewStringUTF(soundName.c_str());
+
+	CheckCommonExceptionWithMessage("Fail in JniPlaySound");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid, jstr);
+}
+
+void JniPlayMusic(const std::string& fileName)
+{
+	*Console<<"In play music\n";
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "PlayMusic", "(Ljava/lang/String;)V");
+	
+	jstring jstr = jenv->NewStringUTF(fileName.c_str());
+
+	CheckCommonExceptionWithMessage("Fail in JniPlayMusic");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid, jstr);
+}
+
+
+void JniPlayMusicLooped(const std::string& fileName)
+{
+    JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "PlayMusicLooped", "(Ljava/lang/String;)V");
+	
+	jstring jstr = jenv->NewStringUTF(fileName.c_str());
+
+	CheckCommonExceptionWithMessage("Fail in JniPlayMusicLooped");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid, jstr);
+}
+
+
+void JniStopMusic()
+{
+	JNIEnv* jenv;
+	
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "StopMusic", "()V");
+
+	CheckCommonExceptionWithMessage("Fail in JniPlayMusicLooped");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid);
+}
+
+void JniReleaseAllSoundsAndMusic()
+{
+	JNIEnv* jenv;
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "ReleaseAllSoundsAndMusic", "()V");
+
+	CheckCommonExceptionWithMessage("Fail in JniReleaseAllSoundsAndMusic");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid);
+}
+
+void JniPauseAllSoundsAndMusic()
+{
+	JNIEnv* jenv;
+	
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "PauseAllSoundsAndMusic", "()V");
+
+	CheckCommonExceptionWithMessage("Fail in JniPauseAllSoundsAndMusic");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid);
+}
+
+void JniResumeAllSoundsAndMusic()
+{
+	JNIEnv* jenv;
+	
+    JavaVirtualMachine->GetEnv((void**)&jenv, JNI_VERSION_1_4);
+
+    jclass clazz = JniTryFindClass(CONST_JAVA_FILESYSTEM_CLASS_NAME);
+    
+	jmethodID mid = JniTryFindStaticMethod(clazz, "ResumeAllSoundsAndMusic", "()V");
+
+	CheckCommonExceptionWithMessage("Fail in JniResumeAllSoundsAndMusic");
+	
+	//Any problem? - see console log
+	jenv->CallStaticVoidMethod(clazz, mid);
+}
+
+
+
+void PrintApkContent()
+{
+	zip* APKArchive = zip_open(ApkFilePath.c_str(), 0, NULL);
+    if (APKArchive == NULL)
+	{
+		throw ErrorToLog("Error in loadAPK");
+	}
+	
+	//Just for debug, print APK contents
+    int numFiles = zip_get_num_files(APKArchive);
+	
+    for (int i=0; i<numFiles; i++)
+	{
+		const char* name = zip_get_name(APKArchive, i, 0);
+        if (name == NULL)
+		{
+			*Console<<"Error reading zip file name at index "+tostr(i)+" "+std::string(name);
+			throw ErrorToLog("Error in loadAPK");
+		}
+		
+		*Console<<"Ok reading zip file name at index "+tostr(i)+" "+std::string(name);
+	}
+	
+	zip_close(APKArchive);
+}
+
+
+
+void LoadApk(const std::string& fileName, std::vector<char>& returnData)
+{
+	
+	//PrintApkContent();
+	
+	if (ApkFilePath == "")
+	{
+		throw ErrorToLog("Apk file path is not set!");
+	}
+	
+	//*Console<<"ApkFilePath = "+ApkFilePath+"\n";
+	
+    zip* APKArchive = zip_open(ApkFilePath.c_str(), 0, NULL);
+	
+    if (APKArchive == NULL)
+	{
+		throw ErrorToLog("Error in loadAPK, apk archive is not valid");
+	}
+  
+    zip_file *zfile = zip_fopen(APKArchive, ("assets/" + fileName).c_str(), 0);
+	
+    char buf[4096];
+
+    if (zfile != NULL)
+    {
+        size_t bytesRead;
+        do
+        {
+            bytesRead = zip_fread(zfile, &buf[0], 4096);
+            returnData.insert(returnData.end(), buf, buf + bytesRead);
+        }
+        while (bytesRead == 4096);
+        zip_fclose(zfile);
+    }
+	else
+    {
+        throw ErrorToLog("Error in loadAPK, data in apk archive is broken: "+fileName);
+    }
+   
+    zip_close(APKArchive);
+    
+}
+
+
+} //namespace SE

src/Utils/PngHelper.cpp

@@ -0,0 +1,133 @@
+#include "include/Utils/PngHelper.h"
+#include "include/Utils/Utils.h"
+
+namespace SE
+{
+
+#ifdef TARGET_ANDROID
+typedef PNG_CONST png_byte        FAR * png_const_bytep;
+#endif
+
+struct TPngReadStruct
+{
+	const boost::shared_array<char>& FileArr;
+	cardinal FileSize;
+	int CurrentPointer;
+	TPngReadStruct(const boost::shared_array<char>& fileArr, cardinal fileSize)
+		: FileArr(fileArr)
+		, FileSize(fileSize)
+		, CurrentPointer(8)
+	{
+	}
+
+};
+
+
+void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+
+
+    png_voidp a = png_get_io_ptr(png_ptr);
+
+	TPngReadStruct* pngReadStruct = reinterpret_cast<TPngReadStruct*>(a);
+
+
+	if (pngReadStruct->CurrentPointer + length >= pngReadStruct->FileSize)
+	{
+		throw ErrorToLog("PNG pointer gone too far!");
+	}
+
+	for (cardinal i = 0; i < length; i++)
+	{
+		data[i] = pngReadStruct->FileArr[pngReadStruct->CurrentPointer + i];
+	}
+
+	pngReadStruct->CurrentPointer += length;
+
+}
+
+
+TPngDataStruct read_png_file(const boost::shared_array<char>& fileArr, cardinal fileSize)
+{
+
+	TPngDataStruct result;
+
+	TPngReadStruct readStruct(fileArr, fileSize);
+
+
+	char header[8];    // 8 is the maximum size that can be checked
+
+	for (cardinal i=0; i<8; i++)
+	{
+		header[i] = fileArr[i];
+	}
+
+
+	if (png_sig_cmp(reinterpret_cast<png_bytep>(header), 0, 8))
+	{
+		throw ErrorToLog("Incorrect PNG file (1)!");
+	}
+
+	/* initialize stuff */
+	result.PngPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+
+	if (!result.PngPtr)
+	{
+		throw ErrorToLog("Incorrect PNG file (2)!");
+	}
+
+	result.InfoPtr = png_create_info_struct(result.PngPtr);
+
+	if (!result.InfoPtr)
+	{
+		throw ErrorToLog("Incorrect PNG file (3)!");
+	}
+
+	if (setjmp(png_jmpbuf(result.PngPtr)))
+	{
+		throw ErrorToLog("Incorrect PNG file (4)!");
+	}
+
+	png_set_read_fn(result.PngPtr, (png_voidp)&readStruct, user_read_data);
+
+	png_set_sig_bytes(result.PngPtr, 8);
+
+	png_read_info(result.PngPtr, result.InfoPtr);
+
+	result.Width = png_get_image_width(result.PngPtr, result.InfoPtr);
+	result.Height = png_get_image_height(result.PngPtr, result.InfoPtr);
+	result.ColorType = png_get_color_type(result.PngPtr, result.InfoPtr);
+	result.BitDepth = png_get_bit_depth(result.PngPtr, result.InfoPtr);
+
+	if (result.BitDepth != 8)
+	{
+		throw ErrorToLog("Incorrect bit depth in png file!");
+	}
+
+	if (result.ColorType != PNG_COLOR_TYPE_RGB && result.ColorType != PNG_COLOR_TYPE_RGBA)
+	{
+		throw ErrorToLog("Incorrect color type in png file!");
+	}
+
+	result.NumberOfPasses = png_set_interlace_handling(result.PngPtr);
+	png_read_update_info(result.PngPtr, result.InfoPtr);
+
+
+	if (setjmp(png_jmpbuf(result.PngPtr)))
+	{
+		throw ErrorToLog("Incorrect PNG file (5)!");
+	}
+
+
+	result.RowPointers = (png_bytep*) malloc(sizeof(png_bytep) * result.Height);
+	for (int y=0; y<result.Height; y++)
+		result.RowPointers[y] = (png_byte*) malloc(png_get_rowbytes(result.PngPtr, result.InfoPtr));
+
+	png_read_image(result.PngPtr, result.RowPointers);
+
+	return result;
+
+}
+
+
+} //namespace SE

src/Utils/SerializeInterface/SerializeInterface.cpp

@@ -0,0 +1,153 @@
+#include "include/Utils/SerializeInterface/SerializeInterface.h"
+#include "include/Engine.h"
+
+#include <boost/algorithm/string.hpp>
+
+
+namespace SE
+{
+
+void ReplaceText(boost::property_tree::ptree& propertyTree, std::map<std::string, std::string>& replaceMap)
+{
+	for (boost::property_tree::ptree::iterator i = propertyTree.begin(); i != propertyTree.end(); )
+	{
+		BOOST_FOREACH(auto& itr, replaceMap)
+		{
+			std::string param = i->second.get<std::string>("");
+			if (param != "")
+			{
+				boost::algorithm::replace_all(param, itr.first, itr.second);
+				i->second.put("", param);
+			}
+		}
+		
+
+		if (i != propertyTree.end())
+		{
+			i++;
+		}
+	}
+}
+
+boost::property_tree::ptree::iterator ReplaceIncludeFile(boost::property_tree::ptree& propertyTree, boost::property_tree::ptree::iterator propertyTreeItr, std::map<std::string, std::string> replaceMap)
+{
+	boost::shared_array<char> xmlFileArr;
+	cardinal xmlFileSize;
+
+	std::string fileName = propertyTreeItr->second.get<std::string>("<xmlattr>.file");
+
+	for (boost::property_tree::ptree::iterator i = propertyTreeItr->second.begin(); i != propertyTreeItr->second.end(); ++i)
+	{
+		if (i->first == "Param")
+		{
+			std::string paramName = i->second.get<std::string>("<xmlattr>.name");
+			std::string paramValue = i->second.get<std::string>("<xmlattr>.value");
+
+			//If value already consist template that can be expanded:
+			while (replaceMap.count(paramValue) != 0)
+			{
+				paramValue = replaceMap[paramValue];
+			}
+
+			replaceMap[paramName] = paramValue;
+		}
+	}
+
+	xmlFileArr = CreateMemFromFile<char>(ResourceManager->PathToResources + fileName, xmlFileSize);
+
+	std::string xmlString = std::string(&xmlFileArr[0], &xmlFileArr[xmlFileSize]);
+
+	std::shared_ptr<boost::property_tree::ptree> includeFileTree = StringToPropertyTree(xmlString, replaceMap);
+
+	boost::property_tree::ptree::iterator newItr = propertyTree.erase(propertyTreeItr);
+	
+	propertyTree.insert(newItr, includeFileTree->begin(), includeFileTree->end());
+
+	if (newItr == propertyTree.begin())
+	{
+		throw ErrorToLog("Property tree logic error - don't know how to handle :(");
+	}
+
+	newItr--;
+	
+	return newItr;
+}
+
+void GetReplaceMapRecoursively(boost::property_tree::ptree& propertyTree, std::map<std::string, std::string> replaceMap)
+{
+	ReplaceText(propertyTree, replaceMap);
+
+	for (boost::property_tree::ptree::iterator i = propertyTree.begin(); i != propertyTree.end(); )
+	{
+		std::map<std::string, std::string> localMap = replaceMap;
+
+		if (i->first == "Include")
+		{
+			i = ReplaceIncludeFile(propertyTree, i, localMap);
+		}
+		else
+		{
+			GetReplaceMapRecoursively(i->second, localMap);
+		}
+
+		BOOST_FOREACH(auto& itr, localMap)
+		{
+			if (localMap.count(itr.second) != 0)
+			{
+				localMap[itr.first] = localMap[itr.second];
+			}
+		}
+
+		if (i != propertyTree.end())
+		{
+			i++;
+		}
+	}
+
+	
+}
+
+
+std::shared_ptr<boost::property_tree::ptree> StringToPropertyTree(std::string xmlCode, std::map<std::string, std::string> replaceMap)
+{
+	std::shared_ptr<boost::property_tree::ptree> propertyTree(new boost::property_tree::ptree);
+
+	std::stringstream stream(xmlCode);
+	
+	try
+	{
+		boost::property_tree::read_xml(stream, *propertyTree);
+
+		//Parsing <include/> tag
+		GetReplaceMapRecoursively(*propertyTree, replaceMap);
+
+
+	}
+	catch(boost::property_tree::xml_parser_error)
+	{
+		throw ErrorToLog("ERROR: xml parse error");
+	}
+
+	return propertyTree;
+
+}
+
+std::shared_ptr<boost::property_tree::ptree> FileToPropertyTree(boost::shared_array<char> xmlFileArr, cardinal xmlFileSize, std::map<std::string, std::string> replaceMap)
+{
+	std::string xmlCode = std::string(&xmlFileArr[0], &xmlFileArr[xmlFileSize]);
+	
+	return StringToPropertyTree(xmlCode, replaceMap);
+}
+
+std::shared_ptr<boost::property_tree::ptree> FileToPropertyTree(const std::string& fileName, std::map<std::string, std::string> replaceMap)
+{
+	cardinal byteCount;
+
+	boost::shared_array<char> file = CreateMemFromFile<char>(ResourceManager->PathToResources + fileName, byteCount);
+	
+	return FileToPropertyTree(file, byteCount, replaceMap);
+}
+
+
+
+} //namespace SE

src/Utils/SimpleTimer.cpp

@@ -0,0 +1,37 @@
+#include "include/Utils/SimpleTimer.h"
+
+
+namespace SE
+{
+
+TSimpleTimer::TSimpleTimer()
+	: Timer(0)
+{
+}
+
+
+void TSimpleTimer::SetTimer(int timer)
+{
+	Timer = timer;
+}
+
+void TSimpleTimer::Update(cardinal dt)
+{
+	if (Timer > 0)
+	{
+		Timer = max(Timer - static_cast<int>(dt), 0);
+	}
+}
+
+bool TSimpleTimer::IsOver()
+{
+	return Timer == 0;
+}
+
+boost::posix_time::time_duration TSimpleTimer::GetPosixTime()
+{
+	return boost::posix_time::seconds(Timer / 1000);
+}
+
+
+} //namespace SE

src/Utils/WinApi/WinApi.cpp

@@ -0,0 +1,36 @@
+#include "include/Engine.h"
+
+namespace SE
+{
+
+/*
+Here goes all functions that are platform-specific
+When I make iOS/Mac/Linux port, I will make same API pair h/cpp 
+ */
+
+void GetWindowWidthHeight(int& width, int& height)
+{
+	RECT rc;
+	GetClientRect(Hwnd, &rc);
+
+	width = rc.right;
+	height = rc.bottom;
+}
+
+int GetWindowWidth()
+{
+	RECT rc;
+	GetClientRect(Hwnd, &rc);
+
+	return rc.right;
+}
+
+int GetWindowHeight()
+{
+	RECT rc;
+	GetClientRect(Hwnd, &rc);
+
+	return rc.bottom;
+}
+
+} //namespace SE