First blood

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