blame: source/code/Libs/NFont.cpp

/*

NFont: A font class for SDL and SDL_Renderer

by Jonathan Dearborn

See NFont.h for license info.

*/

#include "NFont.h"

#include "SDL_FontCache.h"

#include <cmath>

#include <cstdio>

#ifndef M_PI

    #define M_PI 3.14159265358979323846

#endif

#include <string>

#include <cstring>

#include <list>

using std::string;

using std::list;

#ifdef NFONT_USE_SDL_GPU

#define NFont_Target GPU_Target

#define NFont_Image GPU_Image

#define NFont_Log GPU_LogError

#else

#define NFont_Target SDL_Renderer

#define NFont_Image SDL_Texture

#define NFont_Log SDL_Log

#endif

#define MIN(a,b) ((a) < (b)? (a) : (b))

#define MAX(a,b) ((a) > (b)? (a) : (b))

#define NFONT_BUFFER_SIZE 1024

// vsnprintf replacement adapted from Valentin Milea:

// http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010

#if defined(_MSC_VER) && _MSC_VER < 1900

#define vsnprintf c99_vsnprintf

static int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)

{

    int count = -1;

    if (size != 0)

        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);

    if (count == -1)

        count = _vscprintf(format, ap);

    return count;

}

#endif

static inline SDL_Surface* createSurface24(Uint32 width, Uint32 height)

{

    #if SDL_BYTEORDER == SDL_BIG_ENDIAN

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 24, 0xFF0000, 0x00FF00, 0x0000FF, 0);

    #else

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 24, 0x0000FF, 0x00FF00, 0xFF0000, 0);

    #endif

}

static inline SDL_Surface* createSurface32(Uint32 width, Uint32 height)

{

    #if SDL_BYTEORDER == SDL_BIG_ENDIAN

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);

    #else

        return SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000);

    #endif

}

static inline char* copyString(const char* c)

{

    if(c == NULL)

        return NULL;

    char* result = new char[strlen(c)+1];

    strcpy(result, c);

    return result;

}

static inline Uint32 getPixel(SDL_Surface *Surface, int x, int y)

{

    Uint8* bits;

    Uint32 bpp;

    if(x < 0 || x >= Surface->w)

        return 0;  // Best I could do for errors

    bpp = Surface->format->BytesPerPixel;

    bits = ((Uint8*)Surface->pixels) + y*Surface->pitch + x*bpp;

    switch (bpp)

    {

        case 1:

            return *((Uint8*)Surface->pixels + y * Surface->pitch + x);

            break;

        case 2:

            return *((Uint16*)Surface->pixels + y * Surface->pitch/2 + x);

            break;

        case 3:

            // Endian-correct, but slower

            Uint8 r, g, b;

            r = *((bits)+Surface->format->Rshift/8);

            g = *((bits)+Surface->format->Gshift/8);

            b = *((bits)+Surface->format->Bshift/8);

            return SDL_MapRGB(Surface->format, r, g, b);

            break;

        case 4:

            return *((Uint32*)Surface->pixels + y * Surface->pitch/4 + x);

            break;

    }

    return 0;  // FIXME: Handle errors better

}

static inline void setPixel(SDL_Surface* surface, int x, int y, Uint32 color)

{

    int bpp = surface->format->BytesPerPixel;

    Uint8* bits = ((Uint8 *)surface->pixels) + y*surface->pitch + x*bpp;

    /* Set the pixel */

    switch(bpp)

    {

        case 1:

            *((Uint8 *)(bits)) = (Uint8)color;

            break;

        case 2:

            *((Uint16 *)(bits)) = (Uint16)color;

            break;

        case 3: { /* Format/endian independent */

            Uint8 r,g,b;

            r = (color >> surface->format->Rshift) & 0xFF;

            g = (color >> surface->format->Gshift) & 0xFF;

            b = (color >> surface->format->Bshift) & 0xFF;

            *((bits)+surface->format->Rshift/8) = r;

            *((bits)+surface->format->Gshift/8) = g;

            *((bits)+surface->format->Bshift/8) = b;

            }

            break;

        case 4:

            *((Uint32 *)(bits)) = (Uint32)color;

            break;

    }

}

static inline void drawPixel(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color, Uint8 alpha)

{

	if(x > surface->clip_rect.x + surface->clip_rect.w || x < surface->clip_rect.x || y > surface->clip_rect.y + surface->clip_rect.h || y < surface->clip_rect.y)

        return;

    switch (surface->format->BytesPerPixel)

    {

        case 1: { /* Assuming 8-bpp */

                Uint8 *pixel = (Uint8 *)surface->pixels + y*surface->pitch + x;

                Uint8 dR = surface->format->palette->colors[*pixel].r;

                Uint8 dG = surface->format->palette->colors[*pixel].g;

                Uint8 dB = surface->format->palette->colors[*pixel].b;

                Uint8 sR = surface->format->palette->colors[color].r;

                Uint8 sG = surface->format->palette->colors[color].g;

                Uint8 sB = surface->format->palette->colors[color].b;

                dR = dR + ((sR-dR)*alpha >> 8);

                dG = dG + ((sG-dG)*alpha >> 8);

                dB = dB + ((sB-dB)*alpha >> 8);

                *pixel = SDL_MapRGB(surface->format, dR, dG, dB);

        }

        break;

        case 2: { /* Probably 15-bpp or 16-bpp */

                Uint32 Rmask = surface->format->Rmask, Gmask = surface->format->Gmask, Bmask = surface->format->Bmask, Amask = surface->format->Amask;

                Uint16 *pixel = (Uint16 *)surface->pixels + y*surface->pitch/2 + x;

                Uint32 dc = *pixel;

                Uint32 R,G,B,A=0;

                R = ((dc & Rmask) + (( (color & Rmask) - (dc & Rmask) ) * alpha >> 8)) & Rmask;

                G = ((dc & Gmask) + (( (color & Gmask) - (dc & Gmask) ) * alpha >> 8)) & Gmask;

                B = ((dc & Bmask) + (( (color & Bmask) - (dc & Bmask) ) * alpha >> 8)) & Bmask;

                if( Amask )

                    A = ((dc & Amask) + (( (color & Amask) - (dc & Amask) ) * alpha >> 8)) & Amask;

                *pixel= R | G | B | A;

        }

        break;

        case 3: { /* Slow 24-bpp mode, usually not used */

            Uint8 *pix = (Uint8 *)surface->pixels + y * surface->pitch + x*3;

            Uint8 rshift8=surface->format->Rshift/8;

            Uint8 gshift8=surface->format->Gshift/8;

            Uint8 bshift8=surface->format->Bshift/8;

            Uint8 ashift8=surface->format->Ashift/8;

                Uint8 dR, dG, dB, dA;

                Uint8 sR, sG, sB, sA;

                pix = (Uint8 *)surface->pixels + y * surface->pitch + x*3;

                dR = *((pix)+rshift8);

                dG = *((pix)+gshift8);

                dB = *((pix)+bshift8);

                dA = *((pix)+ashift8);

                sR = (color>>surface->format->Rshift)&0xff;

                sG = (color>>surface->format->Gshift)&0xff;

                sB = (color>>surface->format->Bshift)&0xff;

                sA = (color>>surface->format->Ashift)&0xff;

                dR = dR + ((sR-dR)*alpha >> 8);

                dG = dG + ((sG-dG)*alpha >> 8);

                dB = dB + ((sB-dB)*alpha >> 8);

                dA = dA + ((sA-dA)*alpha >> 8);

                *((pix)+rshift8) = dR;

                *((pix)+gshift8) = dG;

                *((pix)+bshift8) = dB;

                *((pix)+ashift8) = dA;

        }

        break;

        case 4: { /* Probably 32-bpp */

            Uint32 Rmask = surface->format->Rmask, Gmask = surface->format->Gmask, Bmask = surface->format->Bmask, Amask = surface->format->Amask;

            Uint32* pixel = (Uint32*)surface->pixels + y*surface->pitch/4 + x;

            Uint32 source = *pixel;

            Uint32 R,G,B,A;

            R = color & Rmask;

            G = color & Gmask;

            B = color & Bmask;

            A = 0;  // keep this as 0 to avoid corruption of non-alpha surfaces

            // Blend and keep dest alpha

            if( alpha != SDL_ALPHA_OPAQUE ){

                R = ((source & Rmask) + (( R - (source & Rmask) ) * alpha >> 8)) & Rmask;

                G = ((source & Gmask) + (( G - (source & Gmask) ) * alpha >> 8)) & Gmask;

                B = ((source & Bmask) + (( B - (source & Bmask) ) * alpha >> 8)) & Bmask;

            }

            if(Amask)

                A = (source & Amask);

            *pixel = R | G | B | A;

        }

        break;

    }

}

static inline NFont::Rectf rectUnion(const NFont::Rectf& A, const NFont::Rectf& B)

{

    float x,x2,y,y2;

    x = MIN(A.x, B.x);

    y = MIN(A.y, B.y);

    x2 = MAX(A.x+A.w, B.x+B.w);

    y2 = MAX(A.y+A.h, B.y+B.h);

    NFont::Rectf result(x, y, MAX(0, x2 - x), MAX(0, y2 - y));

    return result;

}

// Adapted from SDL_IntersectRect

static inline NFont::Rectf rectIntersect(const NFont::Rectf& A, const NFont::Rectf& B)

{

    NFont::Rectf result;

	float Amin, Amax, Bmin, Bmax;

	// Horizontal intersection

	Amin = A.x;

	Amax = Amin + A.w;

	Bmin = B.x;

	Bmax = Bmin + B.w;

	if(Bmin > Amin)

	        Amin = Bmin;

	result.x = Amin;

	if(Bmax < Amax)

	        Amax = Bmax;

	result.w = Amax - Amin > 0 ? Amax - Amin : 0;

	// Vertical intersection

	Amin = A.y;

	Amax = Amin + A.h;

	Bmin = B.y;

	Bmax = Bmin + B.h;

	if(Bmin > Amin)

	        Amin = Bmin;

	result.y = Amin;

	if(Bmax < Amax)

	        Amax = Bmax;

	result.h = Amax - Amin > 0 ? Amax - Amin : 0;

	return result;

}

static inline SDL_Surface* copySurface(SDL_Surface *Surface)

{

    return SDL_ConvertSurface(Surface, Surface->format, Surface->flags);

}

NFont::Color::Color()

    : r(0), g(0), b(0), a(255)

{}

NFont::Color::Color(Uint8 r, Uint8 g, Uint8 b)

    : r(r), g(g), b(b), a(255)

{}

NFont::Color::Color(Uint8 r, Uint8 g, Uint8 b, Uint8 a)

    : r(r), g(g), b(b), a(a)

{}

NFont::Color::Color(const SDL_Color& color)

    : r(color.r), g(color.g), b(color.b), a(color.a)

{}

NFont::Color& NFont::Color::rgb(Uint8 R, Uint8 G, Uint8 B)

{

    r = R;

    g = G;

    b = B;

    return *this;

}

NFont::Color& NFont::Color::rgba(Uint8 R, Uint8 G, Uint8 B, Uint8 A)

{

    r = R;

    g = G;

    b = B;

    a = A;

    return *this;

}

NFont::Color& NFont::Color::color(const SDL_Color& color)

{

    r = color.r;

    g = color.g;

    b = color.b;

    a = color.a;

    return *this;

}

SDL_Color NFont::Color::to_SDL_Color() const

{

    SDL_Color c = {r, g, b, a};

    return c;

}

NFont::Rectf::Rectf()

    : x(0), y(0), w(0), h(0)

{}

NFont::Rectf::Rectf(float x, float y)

    : x(x), y(y), w(0), h(0)

{}

NFont::Rectf::Rectf(float x, float y, float w, float h)

    : x(x), y(y), w(w), h(h)

{}

NFont::Rectf::Rectf(const SDL_Rect& rect)

    : x(rect.x), y(rect.y), w(rect.w), h(rect.h)

{}

#ifdef NFONT_USE_SDL_GPU

NFont::Rectf::Rectf(const GPU_Rect& rect)

    : x(rect.x), y(rect.y), w(rect.w), h(rect.h)

{}

#endif

SDL_Rect NFont::Rectf::to_SDL_Rect() const

{

    SDL_Rect r = {int(x), int(y), int(w), int(h)};

    return r;

}

#ifdef NFONT_USE_SDL_GPU

GPU_Rect NFont::Rectf::to_GPU_Rect() const

{

    return GPU_MakeRect(x, y, w, h);

}

#endif

char* NFont::buffer = NULL;  // Shared buffer for efficient drawing

// Constructors

NFont::NFont()

{

    init();

}

NFont::NFont(const NFont& font)

{

    init();

    // FIXME: Duplicate font data

}

#ifdef NFONT_USE_SDL_GPU

NFont::NFont(TTF_Font* ttf)

{

    init();

    load(ttf, FC_GetDefaultColor(font));

}

NFont::NFont(TTF_Font* ttf, const NFont::Color& color)

{

    init();

    load(ttf, color);

}

NFont::NFont(const char* filename_ttf, Uint32 pointSize)

{

    init();

    load(filename_ttf, pointSize);

}

NFont::NFont(const char* filename_ttf, Uint32 pointSize, const NFont::Color& color, int style)

{

    init();

    load(filename_ttf, pointSize, color, style);

}

NFont::NFont(SDL_RWops* file_rwops_ttf, Uint8 own_rwops, Uint32 pointSize, const NFont::Color& color, int style)

{

    init();

    load(file_rwops_ttf, own_rwops, pointSize, color, style);

}

#else

NFont::NFont(NFont_Target* renderer, TTF_Font* ttf)

{

    init();

    load(renderer, ttf, FC_GetDefaultColor(font));

}

NFont::NFont(NFont_Target* renderer, TTF_Font* ttf, const NFont::Color& color)

{

    init();

    load(renderer, ttf, color);

}

NFont::NFont(NFont_Target* renderer, const char* filename_ttf, Uint32 pointSize)

{

    init();

    load(renderer, filename_ttf, pointSize);

}

NFont::NFont(NFont_Target* renderer, const char* filename_ttf, Uint32 pointSize, const NFont::Color& color, int style)

{

    init();

    load(renderer, filename_ttf, pointSize, color, style);

}

NFont::NFont(NFont_Target* renderer, SDL_RWops* file_rwops_ttf, Uint8 own_rwops, Uint32 pointSize, const NFont::Color& color, int style)

{

    init();

    load(renderer, file_rwops_ttf, own_rwops, pointSize, color, style);

}

#endif

NFont::~NFont()

{

    FC_FreeFont(font);

}

NFont& NFont::operator=(const NFont& font)

{

    // FIXME: Duplicate font data

    return *this;

}

void NFont::init()

{

    font = FC_CreateFont();

    if(buffer == NULL)

        buffer = new char[NFONT_BUFFER_SIZE];

}

void NFont::setLoadingString(const char* str)

{

    FC_SetLoadingString(font, str);

}

#ifdef NFONT_USE_SDL_GPU

bool NFont::load(TTF_Font* ttf)

#else

bool NFont::load(NFont_Target* renderer, TTF_Font* ttf)

#endif

{

    #ifdef NFONT_USE_SDL_GPU

    return load(ttf, FC_GetDefaultColor(font));

    #else

    return load(renderer, ttf, Color(0,0,0,255));

    #endif

}

#ifdef NFONT_USE_SDL_GPU

bool NFont::load(TTF_Font* ttf, const NFont::Color& color)

#else

bool NFont::load(NFont_Target* renderer, TTF_Font* ttf, const NFont::Color& color)

#endif

{

    if(ttf == NULL)

        return false;

    #ifndef NFONT_USE_SDL_GPU

    if(renderer == NULL)

        return false;

    #endif

    FC_ClearFont(font);

    #ifdef NFONT_USE_SDL_GPU

    return FC_LoadFontFromTTF(font, ttf, color.to_SDL_Color());

    #else

    return FC_LoadFontFromTTF(font, renderer, ttf, color.to_SDL_Color());

    #endif

}

#ifdef NFONT_USE_SDL_GPU

bool NFont::load(const char* filename_ttf, Uint32 pointSize)

#else

bool NFont::load(NFont_Target* renderer, const char* filename_ttf, Uint32 pointSize)

#endif

{

    #ifdef NFONT_USE_SDL_GPU

    return load(filename_ttf, pointSize, Color(0,0,0,255));

    #else

    return load(renderer, filename_ttf, pointSize, Color(0,0,0,255));

    #endif

}

#ifdef NFONT_USE_SDL_GPU

bool NFont::load(const char* filename_ttf, Uint32 pointSize, const NFont::Color& color, int style)

#else

bool NFont::load(NFont_Target* renderer, const char* filename_ttf, Uint32 pointSize, const NFont::Color& color, int style)

#endif

{

    FC_ClearFont(font);

    #ifdef NFONT_USE_SDL_GPU

    return FC_LoadFont(font, filename_ttf, pointSize, color.to_SDL_Color(), style);

    #else

    return FC_LoadFont(font, renderer, filename_ttf, pointSize, color.to_SDL_Color(), style);

    #endif

}

#ifdef NFONT_USE_SDL_GPU

bool NFont::load(SDL_RWops* file_rwops_ttf, Uint8 own_rwops, Uint32 pointSize, const NFont::Color& color, int style)

#else

bool NFont::load(NFont_Target* renderer, SDL_RWops* file_rwops_ttf, Uint8 own_rwops, Uint32 pointSize, const NFont::Color& color, int style)

#endif

{

    FC_ClearFont(font);

    #ifdef NFONT_USE_SDL_GPU

    return FC_LoadFont_RW(font, file_rwops_ttf, own_rwops, pointSize, color.to_SDL_Color(), style);

    #else

    return FC_LoadFont_RW(font, renderer, file_rwops_ttf, own_rwops, pointSize, color.to_SDL_Color(), style);

    #endif

}

void NFont::free()

{

    FC_ClearFont(font);

}

NFont::Rectf NFont::draw(NFont_Target* dest, float x, float y, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_Draw(font, dest, x, y, "%s", buffer);

}

/*static int getIndexPastWidth(const char* text, int width, const int* charWidth)

{

    int charnum;

    int len = strlen(text);

    for (int index = 0; index < len; index++)

    {

        char c = text[index];

        charnum = (unsigned char)(c) - 33;

        // spaces and nonprintable characters

        if (c == ' ' || charnum > 222)

        {

            width -= charWidth[0];

        }

        else

            width -= charWidth[charnum];

        if(width <= 0)

            return index;

    }

    return 0;

}*/

/*static list<string> explode(const string& str, char delimiter)

{

    list<string> result;

    size_t oldPos = 0;

    size_t pos = str.find_first_of(delimiter);

    while(pos != string::npos)

    {

        result.push_back(str.substr(oldPos, pos - oldPos));

        oldPos = pos+1;

        pos = str.find_first_of(delimiter, oldPos);

    }

    result.push_back(str.substr(oldPos, string::npos));

    return result;

}*/

NFont::Rectf NFont::drawBox(NFont_Target* dest, const Rectf& box, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(box.x, box.y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    #ifdef NFONT_USE_SDL_GPU

    return FC_DrawBox(font, dest, box.to_GPU_Rect(), "%s", buffer);

    #else

    return FC_DrawBox(font, dest, box.to_SDL_Rect(), "%s", buffer);

    #endif

}

static FC_AlignEnum translate_enum_NFont_to_FC(NFont::AlignEnum align)

{

    switch(align)

    {

    case NFont::LEFT:

        return FC_ALIGN_LEFT;

    case NFont::CENTER:

        return FC_ALIGN_CENTER;

    case NFont::RIGHT:

        return FC_ALIGN_RIGHT;

    default:

        return FC_ALIGN_LEFT;

    }

}

NFont::Rectf NFont::drawBox(NFont_Target* dest, const Rectf& box, AlignEnum align, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(box.x, box.y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    #ifdef NFONT_USE_SDL_GPU

    return FC_DrawBoxAlign(font, dest, box.to_GPU_Rect(), translate_enum_NFont_to_FC(align), "%s", buffer);

    #else

    return FC_DrawBoxAlign(font, dest, box.to_SDL_Rect(), translate_enum_NFont_to_FC(align), "%s", buffer);

    #endif

}

NFont::Rectf NFont::drawBox(NFont_Target* dest, const Rectf& box, const Scale& scale, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(box.x, box.y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    #ifdef NFONT_USE_SDL_GPU

    return FC_DrawBoxScale(font, dest, box.to_GPU_Rect(), FC_MakeScale(scale.x, scale.y), "%s", buffer);

    #else

    return FC_DrawBoxScale(font, dest, box.to_SDL_Rect(), FC_MakeScale(scale.x, scale.y), "%s", buffer);

    #endif

}

NFont::Rectf NFont::drawBox(NFont_Target* dest, const Rectf& box, const Color& color, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(box.x, box.y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    #ifdef NFONT_USE_SDL_GPU

    return FC_DrawBoxColor(font, dest, box.to_GPU_Rect(), color.to_SDL_Color(), "%s", buffer);

    #else

    return FC_DrawBoxColor(font, dest, box.to_SDL_Rect(), color.to_SDL_Color(), "%s", buffer);

    #endif

}

NFont::Rectf NFont::drawBox(NFont_Target* dest, const Rectf& box, const Effect& effect, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(box.x, box.y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    #ifdef NFONT_USE_SDL_GPU

    return FC_DrawBoxEffect(font, dest, box.to_GPU_Rect(), FC_MakeEffect(translate_enum_NFont_to_FC(effect.alignment), FC_MakeScale(effect.scale.x, effect.scale.y), effect.color.to_SDL_Color()), "%s", buffer);

    #else

    return FC_DrawBoxEffect(font, dest, box.to_SDL_Rect(), FC_MakeEffect(translate_enum_NFont_to_FC(effect.alignment), FC_MakeScale(effect.scale.x, effect.scale.y), effect.color.to_SDL_Color()), "%s", buffer);

    #endif

}

NFont::Rectf NFont::drawColumn(NFont_Target* dest, float x, float y, Uint16 width, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawColumn(font, dest, x, y, width, "%s", buffer);

}

NFont::Rectf NFont::drawColumn(NFont_Target* dest, float x, float y, Uint16 width, AlignEnum align, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawColumnAlign(font, dest, x, y, width, translate_enum_NFont_to_FC(align), "%s", buffer);

}

NFont::Rectf NFont::drawColumn(NFont_Target* dest, float x, float y, Uint16 width, const Scale& scale, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawColumnScale(font, dest, x, y, width, FC_MakeScale(scale.x, scale.y), "%s", buffer);

}

NFont::Rectf NFont::drawColumn(NFont_Target* dest, float x, float y, Uint16 width, const Color& color, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawColumnColor(font, dest, x, y, width, color.to_SDL_Color(), "%s", buffer);

}

NFont::Rectf NFont::drawColumn(NFont_Target* dest, float x, float y, Uint16 width, const Effect& effect, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    #ifdef NFONT_USE_SDL_GPU

    return FC_DrawColumnEffect(font, dest, x, y, width, FC_MakeEffect(translate_enum_NFont_to_FC(effect.alignment), FC_MakeScale(effect.scale.x, effect.scale.y), effect.color.to_SDL_Color()), "%s", buffer);

    #else

    return FC_DrawColumnEffect(font, dest, x, y, width, FC_MakeEffect(translate_enum_NFont_to_FC(effect.alignment), FC_MakeScale(effect.scale.x, effect.scale.y), effect.color.to_SDL_Color()), "%s", buffer);

    #endif

}

NFont::Rectf NFont::draw(NFont_Target* dest, float x, float y, const Scale& scale, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawScale(font, dest, x, y, FC_MakeScale(scale.x, scale.y), "%s", buffer);

}

NFont::Rectf NFont::draw(NFont_Target* dest, float x, float y, AlignEnum align, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawAlign(font, dest, x, y, translate_enum_NFont_to_FC(align), "%s", buffer);

}

NFont::Rectf NFont::draw(NFont_Target* dest, float x, float y, const Color& color, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawColor(font, dest, x, y, color.to_SDL_Color(), "%s", buffer);

}

NFont::Rectf NFont::draw(NFont_Target* dest, float x, float y, const Effect& effect, const char* formatted_text, ...)

{

    if(formatted_text == NULL)

        return Rectf(x, y, 0, 0);

    va_list lst;

    va_start(lst, formatted_text);

    vsnprintf(buffer, NFONT_BUFFER_SIZE, formatted_text, lst);

    va_end(lst);

    return FC_DrawEffect(font, dest, x, y, FC_MakeEffect(translate_enum_NFont_to_FC(effect.alignment), FC_MakeScale(effect.scale.x, effect.scale.y), effect.color.to_SDL_Color()), "%s", buffer);

}

// Getters

NFont::FilterEnum NFont::getFilterMode() const

{

    FC_FilterEnum f = FC_GetFilterMode(font);

    if(f == FC_FILTER_LINEAR)

        return NFont::LINEAR;