PlatformFont_RTL.cpp File Reference

#include "PlatformFont.h"
#include "../../objects/PFont.h"
#include "../../objects/PColor.h"
#include "../../utility/PEBLPath.h"
#include "../../utility/PError.h"
#include "../../base/Evaluator.h"
#include "SDL.h"
#include "SDL_ttf.h"
#include "SDL_rwops.h"
#include <stdio.h>
#include <iostream>

Go to the source code of this file.

Functions
bool	is_utf8 (std::string str)
long unsigned int	getFileSize (FILE **file)
char *	getFileBuffer (FILE **file, unsigned int fileSize)
unsigned long int	readFileToMemory (const char path[], char **buffr)
void	RenderTexture (const std::wstring &text)
SDL_Surface *	CreateSurfaceFromFT_Bitmap (const FT_Bitmap &bitmap)
SDL_Texture *	CreateTextureFromFT_Bitmap (SDL_Renderer *renderer, const FT_Bitmap &bitmap, const SDL_Color &color)
void	CalculateSurfaceBound (hb_glyph_info_t *glyph_infos, hb_glyph_position_t *glyph_positions, const unsigned int &glyph_count, const FT_Face &face, SDL_Rect &rect, const FT_Int32 &flags=FT_LOAD_DEFAULT)
void	DrawTextHB (conts std::wstring &Text)

Function Documentation

CalculateSurfaceBound()

void CalculateSurfaceBound	(	hb_glyph_info_t *	glyph_infos,
		hb_glyph_position_t *	glyph_positions,
		const unsigned int &	glyph_count,
		const FT_Face &	face,
		SDL_Rect &	rect,
		const FT_Int32 &	flags = FT_LOAD_DEFAULT
	)

Definition at line 440 of file PlatformFont_RTL.cpp.

{
        int width = 0;
        int above_base_line = 0;
        int below_base_line = 0;
 
        for (unsigned int i = 0; i < glyph_count; i++) 
        {
                FT_Load_Glyph(face, glyph_infos[i].codepoint, FT_LOAD_DEFAULT | flags);
                width += (glyph_positions[i].x_advance >> 6);
                int bearing = 
                        (face->glyph->metrics.horiBearingY >> 6) + (glyph_positions[i].y_offset >> 6);
 
                if (bearing > above_base_line)
                        above_base_line = bearing;
 
                int height_minus_bearing = (face->glyph->metrics.height >> 6) - bearing;
                if (height_minus_bearing > below_base_line)
                        below_base_line = height_minus_bearing;
        }
 
        rect.x = 0;
        rect.y = -above_base_line;
        rect.w = width;
        rect.h = above_base_line + below_base_line;
 
}

Referenced by RenderTexture().

CreateSurfaceFromFT_Bitmap()

SDL_Surface * CreateSurfaceFromFT_Bitmap

(

const FT_Bitmap &

bitmap

)

Definition at line 365 of file PlatformFont_RTL.cpp.

{
    Uint32 rmask, gmask, bmask, amask;
    int req_format = STBI_rgb_alpha;
    
    rmask = 0x000000ff;
    gmask = 0x0000ff00;
    bmask = 0x00ff0000;
    amask = (req_format == STBI_rgb) ? 0 : 0xff000000;
 
    int depth, pitch;
    if (req_format == STBI_rgb) {
        depth = 24;
        pitch = 3*width; // 3 bytes per pixel * pixels per row
    } else { // STBI_rgb_alpha (RGBA)
        depth = 32;
        pitch = 4*width;
    }
 
    //we may have to translate buffer to pixels here.
 
    
    SDL_Surface * tmp = SDL_CreateRGBSurfaceFrom( (void*)(bitmap.buffer),               // dest_buffer from CopyTo
                                                   bitmap.width,        // in pixels
                                                   bitmap.height,       // in pixels
                                                   depth,               // in bits, so should be dest_depth * 8
                                                   pitch,                      // dest_row_span from CopyTo
                                                   rmask,gmask,bmas,amask);        // RGBA masks, see docs
 
    return tmp;
}

Referenced by RenderTexture().

CreateTextureFromFT_Bitmap()

SDL_Texture * CreateTextureFromFT_Bitmap	(	SDL_Renderer *	renderer,
		const FT_Bitmap &	bitmap,
		const SDL_Color &	color
	)

Definition at line 401 of file PlatformFont_RTL.cpp.

{
        SDL_Texture* output = SDL_CreateTexture(renderer,
                SDL_PIXELFORMAT_RGBA8888,
                SDL_TEXTUREACCESS_STREAMING,
                bitmap.width,
                bitmap.rows);
 
        void *buffer;
        int pitch;
        SDL_LockTexture(output, NULL, &buffer, &pitch);
 
        unsigned char *src_pixels = bitmap.buffer;
        unsigned int *target_pixels = reinterpret_cast<unsigned int*>(buffer);
 
        SDL_PixelFormat* pixel_format = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA8888);
 
        for (int y = 0; y < bitmap.rows; y++)
        {
                for (int x = 0; x < bitmap.width; x++)
                {
                        int index = (y * bitmap.width) + x;
 
                        unsigned int alpha = src_pixels[index];
                        unsigned int pixel_value =
                                SDL_MapRGBA(pixel_format, color.r, color.g, color.b, alpha);
 
                        target_pixels[index] = pixel_value;
                }
        }
 
        SDL_FreeFormat(pixel_format);
        SDL_UnlockTexture(output);
 
        return output;
}

References NULL.

DrawTextHB()

void DrawTextHB

(

conts std::wstring &

Text

)

Definition at line 474 of file PlatformFont_RTL.cpp.

{
 
    //These are the arguments originally passed in to the function:
    //const SDL_Color& color,
    SDL_Color& color = mSDL_FGColor;
 
    //const int& baseline,
    const int baseline= 0;
    //const int& x_start,
    const int x_start = 0;
    //const FT_Face& face //===mFace
    //hb_font_t* hb_font, //== mHBFont
    //SDL_Renderer*& renderer //= mRenderer
 
    //this will render directly onto wherever the renderer is currently pointing.
    //This might be smart, but labels and textboxes _expect_ a tmpSurface to be returned.
    //and so we need to create one here to use.
 
 
    
    mSurface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                    (int)mTextureWidth,
                                    (int)mTextureHeight, 32,
                                    rmask, gmask, bmask, amask);
 
    
    if(!mSurface)  PError::SignalFatalError("Surface not created in TextBox::RenderText.");
 
    
        hb_buffer_t *buffer = hb_buffer_create();
 
    //This could be HB_DIRECTION_LTR; HB_DIRECTION_RTL; HB_DIRECTION_TTB, B_DIRECTION_BTT, HB_DIRECTION_INVALID;
    hb_buffer_set_direction(buffer, HB_DIRECTION_LTR);  //hardcode as LTR for testing
 
    //could be HB_SCRIPT_ARABIC
    // HB_SCRIPT_LATIN
    // HB_SCRIPT_INVALID
    //    HB_SCRIPT_UNKNOWN, etc.
    //could use hb_scirpt_from_string to select this:
    hb_buffer_set_script(buffer, HB_SCRIPT_THAI);
 
 
        hb_buffer_add_utf16(buffer, 
                        (unsigned short*)(text.c_str()),
                        text.length(),
                        0, 
                        text.length());
 
        hb_shape(mHBfont, buffer, NULL, 0);
 
        const unsigned int glyph_count = hb_buffer_get_length(buffer);
        const hb_glyph_info_t *glyph_infos = hb_buffer_get_glyph_infos(buffer, NULL);
        const hb_glyph_position_t *glyph_positions = hb_buffer_get_glyph_positions(buffer, NULL);
 
    //This renders directly onto the surface; it does not produce a surface.
        SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_BLEND);
 
        int x = x_start;
 
        SpanAdditionData addl;
 
        addl.color = color;
 
        for (unsigned int i = 0; i < glyph_count; i++)
        {
                FT_Load_Glyph(mFace, glyph_infos[i].codepoint, FT_LOAD_NO_BITMAP);
 
                addl.dest.x = x + (glyph_positions[i].x_offset >> 6);
                addl.dest.y = baseline - (glyph_positions[i].y_offset >> 6);
 
                if (mFace->glyph->format == FT_GLYPH_FORMAT_OUTLINE)
                {
                        FT_Raster_Params params;
                        memset(&params, 0, sizeof(params));
                        params.flags = FT_RASTER_FLAG_AA | FT_RASTER_FLAG_DIRECT;
                        params.gray_spans = DrawSpansCallback;
                        params.user = &addl;
 
                        FT_Outline_Render(library, &mFace->glyph->outline, &params);
                }//No fallback
                x += (glyph_positions[i].x_advance >> 6);
        }
 
        hb_buffer_destroy(buffer);
}

References NULL, and PError::SignalFatalError().

getFileBuffer()

char * getFileBuffer	(	FILE **	file,
		unsigned int	fileSize
	)

Definition at line 170 of file PlatformFont_RTL.cpp.

                                                        {
    char *buffer = (char*)malloc(fileSize + 1);
    fread(buffer, sizeof(char),fileSize,*file);
    return buffer;
}

Referenced by readFileToMemory().

getFileSize()

long unsigned int getFileSize

(

FILE **

file

)

Definition at line 160 of file PlatformFont_RTL.cpp.

                                          {
    long unsigned int size;
    if(fseek(*file, 0, SEEK_END) == -1){ return -1; }
    size = ftell(*file);
    fseek(*file, 0, SEEK_SET);
    return size;
}

Referenced by readFileToMemory().

is_utf8()

bool is_utf8

(

std::string

str

)

Definition at line 73 of file PlatformFont_RTL.cpp.

{
 
 
    if(str.length()==0)
        return false;
 
    const unsigned char * bytes = (const unsigned char *)(str.c_str());
    while(*bytes)
    {
        if(     (// ASCII
                        bytes[0] == 0x09 ||
                        bytes[0] == 0x0A ||
                        bytes[0] == 0x0D ||
                        (0x20 <= bytes[0] && bytes[0] <= 0x7E)
                )
        ) {
                bytes += 1;
                continue;
        }
 
        if(     (// non-overlong 2-byte
                        (0xC2 <= bytes[0] && bytes[0] <= 0xDF) &&
                        (0x80 <= bytes[1] && bytes[1] <= 0xBF)
                )
        ) {
                bytes += 2;
                continue;
        }
 
        if(     (// excluding overlongs
                        bytes[0] == 0xE0 &&
                        (0xA0 <= bytes[1] && bytes[1] <= 0xBF) &&
                        (0x80 <= bytes[2] && bytes[2] <= 0xBF)
                ) ||
                (// straight 3-byte
                        ((0xE1 <= bytes[0] && bytes[0] <= 0xEC) ||
                                bytes[0] == 0xEE ||
                                bytes[0] == 0xEF) &&
                        (0x80 <= bytes[1] && bytes[1] <= 0xBF) &&
                        (0x80 <= bytes[2] && bytes[2] <= 0xBF)
                ) ||
                (// excluding surrogates
                        bytes[0] == 0xED &&
                        (0x80 <= bytes[1] && bytes[1] <= 0x9F) &&
                        (0x80 <= bytes[2] && bytes[2] <= 0xBF)
                )
        ) {
                bytes += 3;
                continue;
        }
 
        if(     (// planes 1-3
                        bytes[0] == 0xF0 &&
                        (0x90 <= bytes[1] && bytes[1] <= 0xBF) &&
                        (0x80 <= bytes[2] && bytes[2] <= 0xBF) &&
                        (0x80 <= bytes[3] && bytes[3] <= 0xBF)
                ) ||
                (// planes 4-15
                        (0xF1 <= bytes[0] && bytes[0] <= 0xF3) &&
                        (0x80 <= bytes[1] && bytes[1] <= 0xBF) &&
                        (0x80 <= bytes[2] && bytes[2] <= 0xBF) &&
                        (0x80 <= bytes[3] && bytes[3] <= 0xBF)
                ) ||
                (// plane 16
                        bytes[0] == 0xF4 &&
                        (0x80 <= bytes[1] && bytes[1] <= 0x8F) &&
                        (0x80 <= bytes[2] && bytes[2] <= 0xBF) &&
                        (0x80 <= bytes[3] && bytes[3] <= 0xBF)
                )
        ) {
                bytes += 4;
                continue;
        }
 
        return false;
    }
 
    return true;
}

Referenced by PEBLUtility::DetectScript().

readFileToMemory()

unsigned long int readFileToMemory	(	const char	path[],
		char **	buffr
	)

Definition at line 176 of file PlatformFont_RTL.cpp.

                                                                    {
 
    unsigned long int fileSize;
    FILE *file = fopen(path, "rb");
    if(file != NULL){
        fileSize = getFileSize(&file);
        //cerr << "FIlesize: " << fileSize << endl;
        char* buff = getFileBuffer(&file,(unsigned int)fileSize);
       
 
        (*buffr) = buff;
 
 
        fclose(file);
        return fileSize;
    }else{
        *buffr = NULL;
        return 0;
    }
}

References getFileBuffer(), getFileSize(), and NULL.

RenderTexture()

void RenderTexture

(

const std::wstring &

text

)

Definition at line 272 of file PlatformFont_RTL.cpp.

{
    //    const SDL_Color& color, //==mSDL_FGColor
    //        const Font& font, // combines mFace and mHBFont
    //        SDL_Renderer*& renderer, //==mRenderer
 
    //        SDL_Texture*& target, //mTarget???
    //        SDL_Rect& rect)
 
    const FT_Int32& flags = FT_LOAD_DEFAULT;
 
    
        hb_buffer_t *buffer = hb_buffer_create();
 
    //This could be HB_DIRECTION_LTR; HB_DIRECTION_RTL; HB_DIRECTION_TTB, B_DIRECTION_BTT, HB_DIRECTION_INVALID;
    hb_buffer_set_direction(buffer, HB_DIRECTION_LTR);  //hardcode as LTR for testing
 
    //could be HB_SCRIPT_ARABIC
    // HB_SCRIPT_LATIN
    // HB_SCRIPT_INVALID
    //    HB_SCRIPT_UNKNOWN, etc.
    //could use hb_scirpt_from_string to select this:
    hb_buffer_set_script(buffer, HB_SCRIPT_THAI);
 
 
 
 
    
        hb_buffer_add_utf16(buffer, 
                (unsigned short*)(text.c_str()), 
                text.length(),
                        0, text.length());
 
        hb_shape(mHBFont, buffer, NULL, 0);
 
        unsigned int glyph_count = hb_buffer_get_length(buffer);
        hb_glyph_info_t *glyph_infos = hb_buffer_get_glyph_infos(buffer, NULL);
        hb_glyph_position_t *glyph_positions = hb_buffer_get_glyph_positions(buffer, NULL);
 
    SDL_Rect rect;  //get size of rendering.
 
        CalculateSurfaceBound(glyph_infos, 
                          glyph_positions, 
                          glyph_count, 
                          mFace,
                          rect, 
                          flags);
 
        mTarget = SDL_CreateTexture(mRenderer, 
                                SDL_PIXELFORMAT_ARGB8888,
                                SDL_TEXTUREACCESS_TARGET, 
                                rect.w, 
                                rect.h);
 
    SDL_SetTextureBlendMode(mTarget, SDL_BLENDMODE_BLEND);
    SDL_SetRenderTarget(mRenderer, mTarget);
        SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_BLEND);
        SDL_SetRenderDrawColor(mRenderer, 0, 0, 0, 0);
        SDL_RenderClear(mRenderer);
        SDL_RenderFillRect(mRenderer, NULL);
 
        int baseline = -rect.y;
        int x = 0;
 
        for (unsigned int i = 0; i < glyph_count; i++) 
        {
                FT_Load_Glyph( mFace, 
                        glyph_infos[i].codepoint,
                        FT_LOAD_RENDER | flags);
                
                SDL_Surface* glyph_surface = CreateSurfaceFromFT_Bitmap(mFace->glyph->bitmap);//used to take a color--maybe this is needed?
 
                SDL_Rect dest;
                SDL_QueryTexture(glyph_texture, NULL, NULL, &dest.w, &dest.h);
                dest.x = x + (mFace->glyph->metrics.horiBearingX >> 6) + (glyph_positions[i].x_offset >> 6);
                dest.y = baseline - (mFace->glyph->metrics.horiBearingY >> 6) - (glyph_positions[i].y_offset >> 6);
 
 
                SDL_RenderCopy(mRenderer, glyph_texture, NULL, &dest);
 
                x += (glyph_positions[i].x_advance >> 6);
 
                SDL_DestroyTexture(glyph_texture);
        }
 
        hb_buffer_destroy(buffer);
 
        SDL_SetRenderTarget(mRenderer, NULL);
    return 
}

References CalculateSurfaceBound(), CreateSurfaceFromFT_Bitmap(), and NULL.