bool Texture::loadTexture2D(std::string _file, bool generateMipmaps)
{
	Logger::getInstance()->write(StringUtils::format("Loading texture '%s'", _file.c_str()));

	is3D = false;

	FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(_file.c_str(), 0);
	FIBITMAP *dib = FreeImage_Load(fifmt, _file.c_str(),0);
	FreeImage_SetTransparent(dib,true);
	dib = FreeImage_ConvertTo32Bits(dib); 
	
    if( dib != NULL )
	{
        glGenTextures(1, &textureId);
		glBindTexture(GL_TEXTURE_2D, textureId);

		BYTE *bytes = new BYTE[FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib) * 4];

		width = FreeImage_GetWidth(dib);
		height = FreeImage_GetHeight(dib);

		BYTE *pixels = (BYTE*)FreeImage_GetBits(dib);

		for(unsigned int pixel = 0; pixel < FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib); pixel++)
		{
			bytes[pixel*3+0] = pixels[pixel*3+2];
			bytes[pixel*3+1] = pixels[pixel*3+1];
			bytes[pixel*3+2] = pixels[pixel*3+0];
			bytes[pixel*3+3] = pixels[pixel*3+3];
		}
	     
		glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0,
				GL_RGBA, GL_UNSIGNED_BYTE, bytes);

		bitsPerPixel = FreeImage_GetBPP(dib);

		if(generateMipmaps)
		{
			glGenerateMipmap(GL_TEXTURE_2D);
			mipMapsGenerated = true;
		}

		glGenSamplers(1, &samplerId);
		
		FreeImage_Unload(dib);
		delete bytes;

		setFiltering(TextureFiltering::TEXTURE_FILTER_MAG_BILINEAR, TextureFiltering::TEXTURE_FILTER_MIN_BILINEAR);
		setSamplerParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		setSamplerParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		Logger::getInstance()->write(StringUtils::format("Loaded texture '%s'", _file.c_str()));

		return true;
	}

	Logger::getInstance()->write(StringUtils::format("Error loading texture '%s'", _file.c_str()));

	return false;
}

void Texture::setFiltering(TextureFiltering::_TextureFiltering _tfMagnification, TextureFiltering::_TextureFiltering _tfMinification)
{
	if(_tfMagnification == TextureFiltering::TEXTURE_FILTER_MAG_NEAREST)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}
	else if(_tfMagnification == TextureFiltering::TEXTURE_FILTER_MAG_BILINEAR)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	}

	if(_tfMinification == TextureFiltering::TEXTURE_FILTER_MIN_NEAREST)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	}
	else if(_tfMinification == TextureFiltering::TEXTURE_FILTER_MIN_BILINEAR)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	}
	else if(_tfMinification == TextureFiltering::TEXTURE_FILTER_MIN_NEAREST_MIPMAP)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
	}
	else if(_tfMinification == TextureFiltering::TEXTURE_FILTER_MIN_BILINEAR_MIPMAP)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
	}
	else if(_tfMinification == TextureFiltering::TEXTURE_FILTER_MIN_TRILINEAR)
	{
		glSamplerParameteri(samplerId, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	}

	tfMinification = _tfMinification;
	tfMagnification = _tfMagnification;
}

void Texture::setSamplerParameter(GLenum parameter, GLenum value)
{
	glSamplerParameteri(samplerId, parameter, value);
}