Esempio n. 1
0
bool CRenderTarget::Clear() const
{
	OPENGL_CHECK_FOR_ERRORS();
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	OPENGL_CHECK_FOR_ERRORS();
	return false;
}
Esempio n. 2
0
bool CRenderTarget::BindColorTexture(axelynx::Texture* tex, int layer)
{
	OPENGL_CHECK_FOR_ERRORS();
	// указываем для текущего FBO текстуру, куда следует производить рендер глубины
	glBindFramebuffer(GL_FRAMEBUFFER, fbo_); 

	if(tex)
	{
		CTexture *ctex = dynamic_cast<CTexture*>(tex);
		glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + layer, ctex->GetHandle(), 0);
		used_layer_[layer] = true;
	}
	else
	{
		glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + layer, 0, 0);
		used_layer_[layer] = false;
	}

	if(current_)
		current_->Bind();
	else
		glBindFramebuffer(GL_FRAMEBUFFER, 0); 
	OPENGL_CHECK_FOR_ERRORS();
	return true;
}
Esempio n. 3
0
bool CRenderTarget::Bind3DTexture(axelynx::Texture* tex, int texlayer, int rendertargetlayer)
{
	OPENGL_CHECK_FOR_ERRORS();
	


	glBindFramebuffer(GL_FRAMEBUFFER, fbo_); 
	OPENGL_CHECK_FOR_ERRORS();

	if(tex)
	{
		CTexture *ctex = dynamic_cast<CTexture*>(tex);
		glFramebufferTexture3D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + rendertargetlayer, GL_TEXTURE_3D, ctex->GetHandle(), 0, texlayer);
		used_layer_[rendertargetlayer] = true;
	}
	else
	{
		glFramebufferTexture3D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + rendertargetlayer, GL_TEXTURE_3D, 0, 0, texlayer);
		used_layer_[rendertargetlayer] = false;
	}

	OPENGL_CHECK_FOR_ERRORS();

	if(current_)
		current_->Bind();
	else
		glBindFramebuffer(GL_FRAMEBUFFER, 0); 

	
	OPENGL_CHECK_FOR_ERRORS();
	return true;
}
Esempio n. 4
0
bool CRenderTarget::UnBind(bool restore) const
{
	OPENGL_CHECK_FOR_ERRORS();
	CCanvas::ResizeCanvas(old_width_,old_height_);
	if(restore)
		if(restored_)
			restored_->Bind();

	if(current_)
		glBindFramebuffer(GL_FRAMEBUFFER, 0);

	current_ = 0;
	OPENGL_CHECK_FOR_ERRORS();
	return true;
}
Esempio n. 5
0
vec2 Terrain::LoadVertices(
	const QuadTree<TerrainNode>::Iterator& node, 
	const Image& hmap
	)
{
	//Setup vertex data
	vec2 res = vec2(1.0f, 0.0f);
	int verticesCount = (lodResolution + 1) * (lodResolution + 1);
	vector<vec3> vertices(verticesCount), colors(verticesCount);
	float deltaX = 1.0f / node.LayerSize() / lodResolution;
	float deltaY = 1.0f / node.LayerSize() / lodResolution;
	float x = node.OffsetFloat().x;
	for (int i = 0; i <= lodResolution; i++, x += deltaX)
	{
		float y = node.OffsetFloat().y;
		for (int j = 0; j <= lodResolution; j++, y += deltaY)
		{
			float h = hmap[vec2(x, y)].x;
			res = UniteSegments(res, vec2(h));

			vertices[i*lodResolution + i + j] = vec3(x, h, y);
			colors[i*lodResolution + i + j] = vec3(0.2f, 0.2f + h, 0.4f - h);
		}
	}

	// VAO allocation
	glGenVertexArrays(1, &node->vaoID);
	// VAO setup
	glBindVertexArray(node->vaoID);
	// VBOs allocation
	glGenBuffers(2, node->vboID);
	// VBOs setup
	// vertices buffer
	glBindBuffer(GL_ARRAY_BUFFER, node->vboID[0]);
	glBufferData(GL_ARRAY_BUFFER, vertices.size() * 3 * sizeof(GLfloat), vertices.data(), GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0);
	glEnableVertexAttribArray(0);
	// colors buffer
	glBindBuffer(GL_ARRAY_BUFFER, node->vboID[1]);
	glBufferData(GL_ARRAY_BUFFER, colors.size() * 3 * sizeof(GLfloat), colors.data(), GL_STATIC_DRAW);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0);
	glEnableVertexAttribArray(1);
	// indices buffer
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, GetIndicesBufferID());

	OPENGL_CHECK_FOR_ERRORS();
	// release vertex data
	vertices.clear();
	colors.clear();

	if (node.Level() < maxLOD)
	{
        for (int i : {0, 1, 2, 3})
            res = UniteSegments(res, LoadVertices(node.Add(i), hmap));
	}
	node->heights = res;

	return res;
}
Esempio n. 6
0
void Mesh::Create(){
    glGenBuffers(1,&this->VertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER,this->VertexBuffer);
    glBufferData(GL_ARRAY_BUFFER,
                 vertices.size()*sizeof(math::Vector3),
                 &vertices[0],
            GL_STATIC_DRAW);
    OPENGL_CHECK_FOR_ERRORS();
}
Esempio n. 7
0
axelynx::Texture* CRenderTarget::CreateDepthTexture()
{
	OPENGL_CHECK_FOR_ERRORS();
	axelynx::Texture::Desc desc;
	desc.TT = axelynx::Texture::TT_DEPTH;
	desc.width = width_;
	desc.height = height_;
	desc.cpp = 1;
	desc.bpc = 4;
	desc.use_mipmaps = false;

	CTexture *tex = new CTexture(desc);

	//tex->Bind();
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	//tex->UnBind();
	tex->Build(0,GL_DEPTH_COMPONENT,GL_DEPTH_COMPONENT32F);
	OPENGL_CHECK_FOR_ERRORS();
	BindDepthTexture(tex);
	OPENGL_CHECK_FOR_ERRORS();
	return tex;
}
Esempio n. 8
0
axelynx::Texture* CRenderTarget::CreateColorTexture(int channels, int channel_size, int layer,bool use_mipmaps)
{
	OPENGL_CHECK_FOR_ERRORS();
	axelynx::Texture::Desc desc;
	desc.TT = axelynx::Texture::TT_2D;
	desc.width = width_;
	desc.height = height_;
	desc.cpp = channels;
	desc.bpc = channel_size;
	desc.use_mipmaps = use_mipmaps;

	CTexture *tex = new CTexture(desc);

	GLenum format;
	GLenum internalformat;
	GetGLTextures(format,internalformat,channels,channel_size);
	tex->Build(0,format,internalformat);
	OPENGL_CHECK_FOR_ERRORS();
	BindColorTexture(tex,layer);
	OPENGL_CHECK_FOR_ERRORS();
	return tex;
}
Esempio n. 9
0
bool CRenderTarget::Bind() const
{
	OPENGL_CHECK_FOR_ERRORS();
	old_width_ = CCanvas::Instance()->GetWidth();
	old_height_ = CCanvas::Instance()->GetHeight();

	CCanvas::ResizeCanvas(width_,height_);

	// проверим текущий FBO на корректность
	GLenum fboStatus;  // создаем FBO для рендера глубины в текстуру
	if ((fboStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER)) != GL_FRAMEBUFFER_COMPLETE)
	{
		LOG_ERROR(L"glCheckFramebufferStatus error");
	}  // возвращаем FBO по-умолчанию glBindFramebuffer(GL_FRAMEBUFFER, 0);

	if(current_ != this)
	{
		restored_ = current_;
		glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
	}

	unsigned int buffers[16];
	int c=0;
	for(int i=0;i<16;++i)
	{
		if(used_layer_[i])
		{
			buffers[c] = GL_COLOR_ATTACHMENT0 + i;
			c++;
		}
	}

	glDrawBuffers(c,buffers);

	current_ = this;
	OPENGL_CHECK_FOR_ERRORS();
	return true;
}
Esempio n. 10
0
bool Shader::loadFromFile(const char* fileName, GLuint type)
{
	GET_CONTEXT();

	GLuint   program;
	std::string shaderName;

	if ((program = glCreateProgram()) == 0){
		LOG_ERROR(boost::str(boost::format("Creating shader program fail (%d)\n") % glGetError()));
		return false;
	}

	// если необходимо создать вершинный шейдер
	if (type & Vertex){
		// им¤ вершинного шейдера
		shaderName    = boost::str(boost::format("%s.vs") % fileName);
		if (!loadShader(shaderName, GL_VERTEX_SHADER, program)){
			glDeleteProgram(program);
			return false;		
		}
	}

	// если необходимо создать фрагментный шейдер
	if (type & Fragment)
	{
		shaderName    = boost::str(boost::format("%s.fs") % fileName);
		if (!loadShader(shaderName, GL_FRAGMENT_SHADER, program)){
			glDeleteProgram(program);
			return false;		
		}
	}

	if (type & Geometry)
	{
		shaderName    = boost::str(boost::format("%s.gs") % fileName);
		if (!loadShader(shaderName, GL_GEOMETRY_SHADER, program)){
			glDeleteProgram(program);
			return false;		
		}
	}

	OPENGL_CHECK_FOR_ERRORS();

	m_program = program;
	return true;
}
Esempio n. 11
0
void UMesh::Initialize()
{
    ComputeBoundSphere();
    InitializeBuffers();

    auto renderer = URenderer::GetInstance();

    renderer->BindVBO(&vb);
    renderer->BindVBO(&ib);

    InitializeMaterial(URenderPass::Normal);
    InitializeMaterial(URenderPass::Depth);
    InitializeMaterial(URenderPass::Forward);
    InitializeMaterial(URenderPass::Deffered);

    OPENGL_CHECK_FOR_ERRORS();
}
Esempio n. 12
0
GLint Shader::shaderProgramStatus(GLuint program, GLenum param)
{
	GET_CONTEXT();

    GLint status = 0, length = 0;
    GLchar buffer[1024];

	glGetProgramiv(program, param, &status);

    if (status != GL_TRUE)
    {
		glGetProgramInfoLog(program, 1024, &length, buffer);
		buffer[length] = '\0';
		LOG_ERROR(boost::str(boost::format("Shader: %s\n") % (const char*)buffer));
    }

    OPENGL_CHECK_FOR_ERRORS();

    return status;
}
Esempio n. 13
0
GLint Shader::getShaderStatus(GLuint shader, GLenum param)
{
	GET_CONTEXT();

    GLint status = 0, length = 0;
    GLchar buffer[4096 * 4];

    glGetShaderiv(shader, param, &status);

    if (status != GL_TRUE)
    {
        glGetShaderInfoLog(shader, 4096 * 4, &length, buffer);
		buffer[length] = '\0';
		LOG_ERROR(boost::str(boost::format("Shader: %s\n") % (const char*)buffer));
    }

    OPENGL_CHECK_FOR_ERRORS();

    return status;
}
Esempio n. 14
0
void GLContext::initContext(){
    if(!_glfwInit()){
        LOG_ERROR("Failed to setup GLFW\n" );
    }
    if(!_glInit()){
        LOG_ERROR("Failed to initialize OpenGL\n" );
    }

    core::World::I().cam.setPerspective(
                GLContext::I().SceneParam.FOV,
                GLContext::I().SceneParam.AspectRatio,
                GLContext::I().SceneParam.zNear,
                GLContext::I().SceneParam.zFar);

    //TODO: Remove it to coll source load procedure
    Program = RenderProgram("Lesson");
    Program.createShader(GL_VERTEX_SHADER ,"data/lesson.vs");
    Program.createShader(GL_FRAGMENT_SHADER ,"data/lesson.fs");
    Program.compile();
    OPENGL_CHECK_FOR_ERRORS();
}
Esempio n. 15
0
// инициализаця OpenGL
bool GLWindowInit(const GLWindow *window)
{
	ASSERT(window);

	// устанавливаем вьюпорт на все окно
	glViewport(0, 0, window->width, window->height);

	// параметры OpenGL
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);

	// создадим и загрузим шейдерную программу
	if ((shaderProgram = ShaderProgramCreateFromMemory(vertexShader, fragmentShader)) == 0)
		return false;

	// собираем созданную и загруженную шейдерную программу
	if (!ShaderProgramLink(shaderProgram))
		return false;

	// сделаем шейдерную программу активной
	ShaderProgramBind(shaderProgram);

	// проверка шейдерной программы на корректность
	if (!ShaderProgramValidate(shaderProgram))
		return false;

	// создадим примитив для сферы
	MeshCreateSphere(mesh, vec3(0.0f, 0.0f, 0.0f), 1.0f);
	
	// создадим и настроим камеру
	CameraCreate(mainCamera, -1.0f, -1.0f, -1.0f);
	CameraOrthographic(mainCamera, -0.5f, 0.5f, -0.5f, 0.5f, -10.0f, 10.0f);
	CameraRotate(mainCamera, (float)(-math_degrees * asin((double)1/sqrt(3.0))), 135.0f, 0.0f);

	// проверим не было ли ошибок
	OPENGL_CHECK_FOR_ERRORS();

	return true;
}
Esempio n. 16
0
bool CScene::ZPassRender()
{
	std::list<axelynx::Camera *>::const_iterator ci = camlist.begin();
	std::list<axelynx::Camera *>::const_iterator ei = camlist.end();

	CEarlyZ::StartEarlyZPass();
	for(;ci!=ei;++ci)
	{
		if((*ci)->isEnabled())
		{
			frame_++;
			(*ci)->Bind();
			CMaterial::Free(); //материал зависит от камеры
			OPENGL_CHECK_FOR_ERRORS();
			for(int i=0;i<256;++i)
			{
				if(visible_groups_[i])
					scenegraph_[i]->Render(*ci);
			}
						(*ci)->UnBind();
			CMaterial::Free(); //материал зависит от камеры
		}
	}

	CShader *cs = CShader::Current();

	if(cs)
		cs->UnBind();

	for(int i=0;i<16;++i)
	{
		CTexture *ct = CTexture::Current(i);
		if(ct)
			ct->UnBind();
	}
	CEarlyZ::EndEarlyZPass();

	zpassed = true;
	return true;
}
Esempio n. 17
0
bool CScene::Render()
{
	std::list<axelynx::Camera *>::const_iterator ci = camlist.begin();
	std::list<axelynx::Camera *>::const_iterator ei = camlist.end();

	OPENGL_CHECK_FOR_ERRORS();
	for(;ci!=ei;++ci)
	{
		if((*ci)->isEnabled())
		{
			frame_++;
			(*ci)->Bind(zpassed?-1:0);
			OPENGL_CHECK_FOR_ERRORS();
			CMaterial::Free(); //материал зависит от камеры
			OPENGL_CHECK_FOR_ERRORS();
			if(zpassed)
			{
				CEarlyZ::StartRenderPass();
			}
			else
			{
				glDepthFunc(GL_LESS);
				glDepthMask(GL_TRUE);
			}
			OPENGL_CHECK_FOR_ERRORS();

			for(int i=0;i<256;++i)
			{
				if(visible_groups_[i])
					scenegraph_[i]->Render(*ci);
			}

			(*ci)->UnBind();
			CMaterial::Free(); //материал зависит от камеры
		}
	}

	OPENGL_CHECK_FOR_ERRORS();
	CShader *cs = CShader::Current();

	if(cs)
		cs->UnBind();

	for(int i=0;i<16;++i)
	{
		CTexture *ct = CTexture::Current(i);
		if(ct)
			ct->UnBind();
	}

	OPENGL_CHECK_FOR_ERRORS();
	if(zpassed)
		CEarlyZ::EndRenderPass();
	OPENGL_CHECK_FOR_ERRORS();
	zpassed = false;
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);
	glDepthMask(GL_TRUE);
	OPENGL_CHECK_FOR_ERRORS();
	return true;
}
Esempio n. 18
0
void Terrain::GenerateIndices()
{
	const int VBOSize = lodResolution * lodResolution * 6 * 16;
	vector<GLuint> indices(VBOSize);
	vector<GLuint>::iterator ptr;
	int i, u, v, count;
	for(i = 0; i < 16; i++)
	{
		ptr = indices.begin() + lodResolution * lodResolution * 6 * i;
		count = 0;
		//
		//UPPER SIDE
		//
		if(i & TERRAIN_GRID_SPARSE_UPPER)
		{
			v = 0;
			ptr[count++] = v;
			ptr[count++] = v + lodResolution + 2;
			ptr[count++] = v + 2;
 
			ptr[count++] = v + 2;
			ptr[count++] = v + lodResolution + 2;
			ptr[count++] = v + lodResolution + 3;

			for (v = 2; v < lodResolution-2 ; v+=2)
			{
				ptr[count++] = v;
				ptr[count++] = v + lodResolution + 1;
				ptr[count++] = v + lodResolution + 2;
 
				ptr[count++] = v;
				ptr[count++] = v + lodResolution + 2;
				ptr[count++] = v + 2;
 
				ptr[count++] = v + 2;
				ptr[count++] = v + lodResolution + 2;
				ptr[count++] = v + lodResolution + 3;
			}

			ptr[count++] = v;						
			ptr[count++] = v + lodResolution + 1;	
			ptr[count++] = v + lodResolution + 2;	
 
			ptr[count++] = v;						
			ptr[count++] = v + lodResolution + 2;	
			ptr[count++] = v + 2;					
		}
		else
		{
			v = 0;
			ptr[count++] = v;						
			ptr[count++] = v + 2 + lodResolution;	
			ptr[count++] = v + 1;					

			for (v = 1; v < lodResolution-1 ; v++)
			{
				ptr[count++] = v;						
				ptr[count++] = v + 2 + lodResolution;	
				ptr[count++] = v + 1;					
 
				ptr[count++] = v;						
				ptr[count++] = v + lodResolution + 1;	
				ptr[count++] = v + lodResolution + 2;	
			}

			ptr[count++] = v;						
			ptr[count++] = v + 1 + lodResolution;	
			ptr[count++] = v + 1;					
		}
		//
		//RIGHT SIDE
		//
		if(i & TERRAIN_GRID_SPARSE_RIGHT)
		{
			u = 0;
			unsigned int aux = u*(lodResolution+1) + lodResolution;
			ptr[count++] = aux;							  
			ptr[count++] = aux + lodResolution;			
			ptr[count++] = aux + 2*lodResolution + 2;	
 
			ptr[count++] = aux + lodResolution;			
			ptr[count++] = aux + 2*lodResolution + 1;	
			ptr[count++] = aux + 2*lodResolution + 2;	

			for (u = 2; u < lodResolution-2 ; u+=2)
			{
				aux = u*(lodResolution+1) + lodResolution;
				ptr[count++] = aux;
				ptr[count++] = aux - 1;						
				ptr[count++] = aux + lodResolution;			
 
				ptr[count++] = aux;
				ptr[count++] = aux + lodResolution;			
				ptr[count++] = aux + 2*lodResolution + 2;	
 
				ptr[count++] = aux + lodResolution;			
				ptr[count++] = aux + 2*lodResolution + 1;	
				ptr[count++] = aux + 2*lodResolution + 2;	
			}

			aux = u*(lodResolution+1) + lodResolution;
			ptr[count++] = aux;  
			ptr[count++] = aux - 1;						
			ptr[count++] = aux + lodResolution;			
 
			ptr[count++] = aux; 
			ptr[count++] = aux + lodResolution;			
			ptr[count++] = aux + 2*lodResolution + 2;	
		}
		else
		{
			u = 0;
			unsigned int aux = u*(lodResolution+1) + lodResolution;
			ptr[count++] = aux;
			ptr[count++] = aux + lodResolution;			
			ptr[count++] = aux + lodResolution + 1;		

			for (u = 1; u < lodResolution-1 ; u++)
			{
				aux = u*(lodResolution+1) + lodResolution;
				ptr[count++] = aux;							   
				ptr[count++] = aux - 1;						
				ptr[count++] = aux + lodResolution;			
 
				ptr[count++] = aux; 
				ptr[count++] = aux + lodResolution;			
				ptr[count++] = aux + lodResolution + 1;		
			}
			aux = u*(lodResolution+1) + lodResolution;
			ptr[count++] = aux;
			ptr[count++] = aux - 1;						
			ptr[count++] = aux + lodResolution + 1;
		}
		//
		//LOWER SIDE
		//
		if(i & TERRAIN_GRID_SPARSE_LOWER)
		{
			v = 0;
			unsigned int aux = (lodResolution-1)*(lodResolution+1) + v;
			ptr[count++] = aux + 1;					
			ptr[count++] = aux + lodResolution + 1;	
			ptr[count++] = aux + lodResolution + 3;	
 
			ptr[count++] = aux + 2;					
			ptr[count++] = aux + 1;					
			ptr[count++] = aux + lodResolution + 3;	

			for (v = 2; v < lodResolution-2 ; v+=2)
			{
				aux = (lodResolution-1)*(lodResolution+1) + v;
				ptr[count++] = aux + 1;					
				ptr[count++] = aux;						
				ptr[count++] = aux + lodResolution + 1;	
 
				ptr[count++] = aux + 1;					
				ptr[count++] = aux + lodResolution + 1;	
				ptr[count++] = aux + lodResolution + 3;	
 
				ptr[count++] = aux + 2;					
				ptr[count++] = aux + 1;					
				ptr[count++] = aux + lodResolution + 3;	
			}
			aux = (lodResolution-1)*(lodResolution+1) + v;
			ptr[count++] = aux + 1;
			ptr[count++] = aux;
			ptr[count++] = aux + lodResolution + 1;
 
			ptr[count++] = aux + 1;					
			ptr[count++] = aux + lodResolution + 1;	
			ptr[count++] = aux + lodResolution + 3;	
		}
		else
		{
			v = 0;
			unsigned int aux = (lodResolution-1)*(lodResolution+1) + v;
			ptr[count++] = aux + 1;					
			ptr[count++] = aux + lodResolution + 1;	
			ptr[count++] = aux + lodResolution + 2;	

			for (v = 1; v < lodResolution-1 ; v++)
			{
				aux = (lodResolution-1)*(lodResolution+1) + v;
				ptr[count++] = aux + 1;					
				ptr[count++] = aux;						
				ptr[count++] = aux + lodResolution + 1;	
 
				ptr[count++] = aux + 1;					
				ptr[count++] = aux + lodResolution + 1;	
				ptr[count++] = aux + lodResolution + 2;	
			}
			aux = (lodResolution - 1)*(lodResolution + 1) + v;
			ptr[count++] = aux;
			ptr[count++] = aux + lodResolution + 1;
			ptr[count++] = aux + lodResolution + 2;
		}
		//
		//LEFT SIDE
		//
		if(i & TERRAIN_GRID_SPARSE_LEFT)
		{
			u = 0;
			unsigned int aux = u*(lodResolution+1);
			ptr[count++] = aux; 
			ptr[count++] = aux + 2*lodResolution + 2;	
			ptr[count++] = aux + lodResolution + 2;		
 
			ptr[count++] = aux + lodResolution + 2;		
			ptr[count++] = aux + 2*lodResolution + 2;	
			ptr[count++] = aux + 2*lodResolution + 3;	

			for (u = 2; u < lodResolution-2 ; u+=2)
			{
				aux = u*(lodResolution+1);
				ptr[count++] = aux + 1;
				ptr[count++] = aux;						
				ptr[count++] = aux + lodResolution + 2;		
 
				ptr[count++] = aux; 
				ptr[count++] = aux + 2*lodResolution + 2;	
				ptr[count++] = aux + lodResolution + 2;		
 
				ptr[count++] = aux + lodResolution + 2;		
				ptr[count++] = aux + 2*lodResolution + 2;	
				ptr[count++] = aux + 2*lodResolution + 3;	
			}

			aux = u*(lodResolution+1);
			ptr[count++] = aux + 1;
			ptr[count++] = aux;						
			ptr[count++] = aux + lodResolution + 2;		
 
			ptr[count++] = aux; 
			ptr[count++] = aux + 2*lodResolution + 2;	
			ptr[count++] = aux + lodResolution + 2;		
		}
		else
		{
			u = 0;
			unsigned int aux = u*(lodResolution+1);
			ptr[count++] = aux; 
			ptr[count++] = aux + lodResolution + 1;		
			ptr[count++] = aux + lodResolution + 2;		

			for (u = 1; u < lodResolution-1 ; u++)
			{
				aux = u*(lodResolution+1);
				ptr[count++] = aux;
				ptr[count++] = aux + lodResolution + 2;		
				ptr[count++] = aux + 1;						
 
				ptr[count++] = aux;  
				ptr[count++] = aux + lodResolution + 1;		
				ptr[count++] = aux + lodResolution + 2;		
			}
			aux = u*(lodResolution+1);
			ptr[count++] = aux;							   
			ptr[count++] = aux + lodResolution + 1;		
			ptr[count++] = aux + 1;						
		}
		//
		//CENTRAL PART
		//
		for (u = 1; u < lodResolution-1; u++)
		{
			for (v = 1; v < lodResolution-1 ; v++)
			{
				const unsigned int aux = u*(lodResolution+1) + v;
				ptr[count++] = aux;						
				ptr[count++] = aux + 2 + lodResolution;	
				ptr[count++] = aux + 1;					
 
				ptr[count++] = aux;						
				ptr[count++] = aux + lodResolution + 1;	
				ptr[count++] = aux + lodResolution + 2;	
			}
		}
		indicesBufferSize[i] = count;
	}

	glGenBuffers(1, &indicesBufferID);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesBufferID);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, VBOSize * sizeof(uint32), indices.data(), GL_STATIC_DRAW);

	OPENGL_CHECK_FOR_ERRORS();
}