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);
}