or even better you precalculate all charsets, then use them when desired i think i will be very very faster.

What I'll do over the next couple of days (when time permits!) is "backport **" my freetype code to grrlib 3.0.1a for you and whoever else is interested. I'll also include a small demo program so you can see how it works.

** I say "backport" as the graphics library used by WiiMP (libwiigfx) is derived from grrlib, but I've modified it so much I can't just copy/paste the freetype portion and expect it to work in standard grrlib.

I'm uploading it now, look for it in the contributions forum in a few minutes  Have fun!

Hi DrTwow,

Your source code is working fine which some text on the screen, but when i call the printfGRRLIB_TextToTexture function around 15 times each video frame the text output is garbages. Therefor i try to change the code to the following idea.

I have adapted your source code a little bit to make more efficient us of the video memory (i allocate 640x480x4 only wants) and then write many text calls (GRRLIB_Printf2) on different location in the same video buffer. Then show this video frame on the screen. But for some unknown reason i do not see any text on the screen. Do you have a idea what i do wrong. See source code below.

wplaat

-------------------------------------------------------------

extern void GRRLIB_InitFreetype(void)
{
    unsigned int error = FT_Init_FreeType(&ftLibrary);
    if (error) {
        exit(0);
    }

    error = FT_New_Memory_Face(ftLibrary, font_ttf, font_ttf_size, 0, &ftFace);
    /* Note: You could also directly load a font from the SD card like this:
    error = FT_New_Face(ftLibrary, "fat3:/apps/myapp/font.ttf", 0, &ftFace); */
   
    if (error == FT_Err_Unknown_File_Format) {
        exit(0);
    } else if (error) {
        /* Some other error */
        exit(0);
    }
}

// Init video buffer
extern void GRRLIB_initTexture2(void)
{
   fontTempLayer = (void*) malloc(640 * 480 * 4);
   if (fontTempLayer == NULL)
   {
      /* Oops! Something went wrong! */
      exit(0);
   }
   
   unsigned int *p = fontTempLayer;
   unsigned int loop = 0;
   for (loop = 0; loop < (640 * 480); ++loop)
   {
     *(p++) = 0x00000000;   
   }   
}

// Write text in video buffer
extern void GRRLIB_Printf2(int x, int y, const char *string, unsigned int fontSize, int color)
{
    unsigned int error = 0;
    int penX = 0;
    int penY = fontSize;
    FT_GlyphSlot slot = ftFace->glyph;
    FT_UInt glyphIndex = 0;
    FT_UInt previousGlyph = 0;
    FT_Bool hasKerning = FT_HAS_KERNING(ftFace);

    /* Convert the string to UTF32 */
    size_t length = strlen(string);
    wchar_t *utf32 = (wchar_t*)malloc(length * sizeof(wchar_t));
    length = mbstowcs(utf32, string, length);
   
    /* Loop over each character, drawing it on to the 4, until the
     * end of the string is reached, or until the pixel width is too wide */
    unsigned int loop = 0;
    for (loop = 0; loop < length; ++loop)
    {
        glyphIndex = FT_Get_Char_Index(ftFace, utf32[ loop ]);
       
        /* To the best of my knowledge, none of the other freetype
         * implementations use kerning, so my method ends up looking
         * slightly better */
        if (hasKerning && previousGlyph && glyphIndex)
        {
            FT_Vector delta;
            FT_Get_Kerning(ftFace, previousGlyph, glyphIndex, FT_KERNING_DEFAULT, &delta);
            penX += delta.x >> 6;
        }
   
        error = FT_Load_Glyph(ftFace, glyphIndex, FT_LOAD_RENDER);
        if (error) {
            /* Whoops, something went wrong trying to load the glyph
             * for this character... you should handle this better */
           
            continue;
        }
   
        if (BlitGlyph2(&slot->bitmap, penX + slot->bitmap_left+x, penY - slot->bitmap_top+y, color) == true)
        {
            /* The glyph was successfully blitted to the buffer, move the pen forwards */
            penX += slot->advance.x >> 6;
            previousGlyph = glyphIndex;
        }
        else
        {
            /* BlitGlyph returned false, the line must be full */
            free(utf32);
            return;
        }
    }

    free(utf32);
}

/* Returns true if the character was draw on to the buffer, false if otherwise */
static bool BlitGlyph2(FT_Bitmap *bitmap, int offset, int top, int color)
{
    int bitmapWidth = bitmap->width;
    int bitmapHeight = bitmap->rows;

    if (offset + bitmapWidth > 640)
    {
        /* Drawing this character would over run the buffer, so don't draw it */
        return false;
    }

    /* Draw the glyph onto the buffer, blitting from the bottom up */
    /* CREDIT: Derived from a function by DragonMinded */
    unsigned char *p = fontTempLayer;
    unsigned int y = 0;
    for (y = 0; y < bitmapHeight; ++y)
    {
        int sywidth = y * bitmapWidth;
        int dywidth = (y + top) * 640;

        unsigned int column = 0;
        for (column = 0; column < bitmapWidth; ++column)
        {
            unsigned int srcloc = column + sywidth;
            unsigned int dstloc = ((column + offset) + dywidth) << 2;
           
            /* Copy the alpha value for this pixel into the texture buffer */
            p[ dstloc + 0 ] = (unsigned char) (color & 0xff);
            p[ dstloc + 1 ] = (unsigned char) ((color >> 8) & 0xff);
            p[ dstloc + 2 ] = (unsigned char) ((color >> 16) & 0xff);
            p[ dstloc + 3 ] = (bitmap->buffer[ srcloc ]);
        }
    }
   
    return true;
}

/* Render the text string to a 4x4RGBA texture, return a pointer to this texture */
extern void *GRRLIB_GetTexture2(void)
{
    /* Create a new buffer, this time to hold the final texture
     * in a format suitable for the Wii */
    void *texture = memalign(32, 640 * 480 * 4);

    /* Convert the RGBA temp buffer to a format usuable by GX */
    BitmapTo4x4RGBA(fontTempLayer, texture, 640, 480);
    DCFlushRange(texture, 640 * 480 * 4);

    /* The temp buffer is no longer required */
    free(fontTempLayer);

    return texture;
}


int main()
{
       // Init video mode .. code is not here
           
    // Init Freetype font library
    GRRLIB_InitFreetype();

       while(true)
       {
         // Init text layer      
         GRRLIB_initTexture2();

         GRRLIB_Printf2(10, 10, "Hello World", 8, 0xffffff);
         GRRLIB_Printf2(10, 100, "Hello World", 12, 0xffffff);
         GRRLIB_Printf2(10, 200, "Hello World", 24, 0xffffff);
         GRRLIB_Printf2(10, 300, "Hello World", 48, 0xffffff);

         // Draw text layer
         void *textTexture = GRRLIB_GetTexture2();
         GRRLIB_DrawImg(0, 0, 640, 480, textTexture, 0, 1.0, 1.0, 255);
         free(textTexture); 
      }
}

Last edited by wplaat (2008-11-26 21:14:38)

Hi DrTwox,

Many, Many thanks for your comments. I will adjust the source code this afternoon and retest it. If it is working stable i will add it in the next release of bibleQuiz (v0.6). Wants again, thanks.....

wplaat