D:/Zythum/DinoKod/Render/Font.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : Font.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 09/09/2002
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Assert.h"
#include "Common/Error.h"
#include "Render/Texture.h"
#include "Render/Render.h"

#include "Render/Font.h"

//--------------------------------------------------------------------------------------------------------------------------
KFont::KFont( KRender* pRender, char* pFontName )
{
        m_pRender               = pRender;
        m_RatioX                = 1.0f;
        m_SpaceX                = 0.0f;
        m_hShader               = KSHADER_NO;
        m_pShaderName   = pFontName ? strdup( pFontName ) : strdup( "Terminal" );
}

//--------------------------------------------------------------------------------------------------------------------------
KFont::~KFont()
{
        if( m_pShaderName )
                Freep( m_pShaderName );
}

//--------------------------------------------------------------------------------------------------------------------------
bool KFont::Init()
{
        KShader*        pShader;
        KTexture*       pTexture;
        KTEXTURE        hTexture;

        // Creation du shader
        m_hShader       = m_pRender->GetpShaderBank()->LoadShader( m_pShaderName );
        pShader         = m_pRender->GetpShaderBank()->GetpShader( m_hShader );

        // Le shader existe ? sinon, on le crée a partir d'une fonte Windows
        if( ( pShader->GetnStages() == 0 ) && ( pShader->m_hTexture == KTEXTURE_NO ) )
        {
                // Creation de la texture
                hTexture        = m_pRender->GetpTextureBank()->CreateTexture( FONT_BITMAP_WIDTH, FONT_BITMAP_HEIGHT, 1, true );
                pTexture        = m_pRender->GetpTextureBank()->GetpTexture( hTexture );

                // Ajoute la texture au shader
                KShaderStage*   pStage          = new KShaderStage();
                pStage->m_pTextureList          = new KTEXTURE[1];
                pStage->m_pTextureList[0]       = hTexture;
                pStage->m_nTextures                     = 1 ;
                pStage->m_StageFlags            = KSSF_BLEND;
                pStage->m_BlendSrc                      = KRBLEND_SRCALPHA;
                pStage->m_BlendDst                      = KRBLEND_INVSRCALPHA;
                pShader->m_StageList.Add( pStage );

                // Creation de la font GDI
                HFONT   hFont;

                hFont = CreateFont( FONT_HEIGHT,                        // height of font
                                                        FONT_WIDTH / 2,                 // average character width
                                                        0,                                              // angle of escapement
                                                        0,                                              // base-line orientation angle
                                                        FW_NORMAL,                              // font weight
                                                        FALSE,                                  // italic attribute option
                                                        FALSE,                                  // underline attribute option
                                                        FALSE,                                  // strikeout attribute option
                                                        DEFAULT_CHARSET,                // character set identifier
                                                        OUT_DEFAULT_PRECIS,             // output precision
                                                        CLIP_DEFAULT_PRECIS,    // clipping precision
                                                        ANTIALIASED_QUALITY,//PROOF_QUALITY,            // output quality
                                                        DEFAULT_PITCH,                  // pitch and family
        //                                              "Small fonts"   );              // typeface name
        //                                              "Terminal"      );              // typeface name
        //                                              "Comic Sans MS" );              // typeface name
        //                                              "Tahoma"        );              // typeface name
        //                                              "Verdana"       );              // typeface name
        //                                              "Arial" );              // typeface name
                                                        m_pShaderName   );              // typeface name


                // Creation du Device Context de la bitmap
                HDC             hDC;
                HDC             hBitmapDC;

                hDC = GetDC( m_pRender->GetWindow() );
                hBitmapDC = CreateCompatibleDC( hDC );
                ReleaseDC( m_pRender->GetWindow(), hDC );

                // Creation de la bitmap
                HBITMAP hBitmap;

                hBitmap = CreateCompatibleBitmap( hBitmapDC, FONT_BITMAP_WIDTH, FONT_BITMAP_HEIGHT );
                SelectObject( hBitmapDC, hBitmap );

                // Affiche la font dans la bitmap
                char    Char;
                RECT    Rect;

                SetBkColor( hBitmapDC, RGB( 0, 0, 0 ) );
                SetTextColor( hBitmapDC, RGB( 255, 255, 255 ) );
                SelectObject( hBitmapDC, hFont );

                for( s32 fy = 0; fy < FONT_NHEIGHT; fy ++ )
                {
                        for( s32 fx = 0; fx < FONT_NWIDTH; fx ++ )
                        {
                                Char = (char)(fy * FONT_NWIDTH + fx);
//                              TextOut( hBitmapDC, fx * FONT_WIDTH + 1, fy * FONT_HEIGHT, &Char, 1 ); 
                                Rect.left       = fx * FONT_WIDTH;
                                Rect.top        = fy * FONT_HEIGHT; 
                                Rect.right      = Rect.left + FONT_WIDTH; 
                                Rect.bottom     = Rect.top + FONT_HEIGHT; 
                                DrawText( hBitmapDC, &Char, 1, &Rect, 0 );
                        }
                }

                // Copie la bitmap vers la texture
                COLORREF        ColorRef;
                u32                     r, g, b, a;

                pTexture->Lock();

                for( u32 y = 0; y < FONT_BITMAP_HEIGHT; y ++ )
                {
                        for( u32 x = 0; x < FONT_BITMAP_WIDTH; x ++ )
                        {
                                ColorRef = GetPixel( hBitmapDC, x, y );
                                r = ( ColorRef & 0x000000FF );
                                g = (( ColorRef & 0x0000FF00 ) >> 8 );
                                b = (( ColorRef & 0x00FF0000 ) >> 16 );
                                a = (r + g + b) ? 255 : 0;
                                pTexture->SetPixel( x, y, KRGBA( r, g, b, a ) );
                        }
                }

                pTexture->Unlock();
        }

        GenerateCropTable();

        return true;
}

//--------------------------------------------------------------------------------------------------------------------------
void KFont::End()
{
        KASSERT( m_pRender );

        m_pRender->GetpShaderBank()->UnloadShader( m_hShader );
}

//--------------------------------------------------------------------------------------------------------------------------
bool KFont::CheckAlphaPixel( KTexture* pTexture, u32 x, u32 y, u8* pBits )
{
        u8*             pPixel;

        // Recherche si le pixel a un alpha > 0
        if( ( x < 0 ) || ( x > pTexture->GetWidth() ) || ( y < 0 ) || ( y > pTexture->GetHeight() ) )
        {
                KError::Error( m_pRender->GetWindow(), "KFont::CheckAlphaPixel(...) : Value out of range : x:%i/%i - y:%i/%i", x, FONT_BITMAP_WIDTH, y, FONT_BITMAP_HEIGHT );
                return false;
        }

        switch( pTexture->GetFormat() )
        {
        case KTF_A4R4G4B4:
                pPixel = &pBits[(pTexture->GetWidth() * y + x) * 2];
                return (*((u16*)pPixel) & 0xF000) ? true : false;

        case KTF_A8R8G8B8:
                pPixel = &pBits[(pTexture->GetWidth() * y + x) * 4];
                return (*((u32*)pPixel) & 0xFF000000) ? true : false;

        default:
                KError::Error( m_pRender->GetWindow(), "KFont::CheckAlphaPixel(...) : Font texture format not implemented" );
        }

        return false;
}

//--------------------------------------------------------------------------------------------------------------------------
void KFont::GenerateCropTable()
{
        KShader*        pShader;
        KTexture*       pTexture;
        u8*                     pBits = NULL;
        bool            bAlpha;

        // Generation d'une table de découpage pour permettre de coller les caracteres en supprimant les espaces
        pShader         = m_pRender->GetpShaderBank()->GetpShader( m_hShader );
        KASSERT( pShader );
        if( ( !pShader->GetnStages() ) || ( !pShader->m_StageList[0] ) || ( pShader->m_StageList[0]->m_pTextureList[0] == KTEXTURE_NO ) )
        {
                KError::Error( m_pRender->GetWindow(), "KFont::GenerateCropTable(...) : The font shader need a font bitmap in first stage" );
                return;
        }

        pTexture        = m_pRender->GetpTextureBank()->GetpTexture( pShader->m_StageList[0]->m_pTextureList[0] );
        
        pTexture->Lock( (void**)&pBits );

        for( u32 c = 0; c < 256; c ++ )
        {
                m_CropTable[c].x1 = 0;
                m_CropTable[c].x2 = FONT_WIDTH - 1;
                m_CropTable[c].y1 = 0;
                m_CropTable[c].y2 = FONT_HEIGHT - 1;

                // Supprime l'espace gauche
                m_CropTable[c].x1 = 0;
                for( u32 x1 = 0; x1 < FONT_WIDTH; x1 ++ )
                {
                        bAlpha = false;
                        for( u32 y = 0; y < FONT_HEIGHT; y ++ )
                        {
                                if( CheckAlphaPixel(    pTexture,
                                                                                ( ( c * FONT_WIDTH ) % FONT_BITMAP_WIDTH ) + x1,
                                                                                ( ( c * FONT_WIDTH ) / FONT_BITMAP_WIDTH ) * FONT_HEIGHT + y,
                                                                                pBits ) )
                                {
                                        bAlpha = true;
                                        break;
                                }
                        }
                        if( bAlpha )
                        {
                                m_CropTable[c].x1 = x1;
                                break;
                        }
                }

                // Supprime l'espace droit
                m_CropTable[c].x2 = FONT_HEIGHT - 1;
                for( u32 x2 = FONT_WIDTH - 1; x2 > 0; x2 -- )
                {
                        bAlpha = false;
                        for( u32 y = 0; y < FONT_HEIGHT; y ++ )
                        {
                                if( CheckAlphaPixel(    pTexture,
                                                                                ( ( c * FONT_WIDTH ) % FONT_BITMAP_WIDTH ) + x2,
                                                                                ( ( c * FONT_WIDTH ) / FONT_BITMAP_WIDTH ) * FONT_HEIGHT + y,
                                                                                pBits ) )
                                {
                                        bAlpha = true;
                                        break;
                                }
                        }
                        if( bAlpha )
                        {
                                m_CropTable[c].x2 = x2 + 1;
                                break;
                        }
                }

                //  Laisse un ecart maximum ( bug de l'espace par exemple )
                if( !bAlpha )
                {
                        m_CropTable[c].x1 = 0;
                        m_CropTable[c].x2 = FONT_SPACE_WIDTH;
                }
        }

        pTexture->Unlock();
}

//--------------------------------------------------------------------------------------------------------------------------
KPt KFont::GetCharSize( char Car, float FontSize )
{
        if( Car < 32 )
                return KPt( 0, 0 );

//      FontSize /= 2.0f;

        s32     SizeX = s32( (float)(m_CropTable[Car].x2 - m_CropTable[Car].x1 + 1) * m_RatioX * FontSize );
        s32     SizeY = s32( (float)(m_CropTable[Car].y2 - m_CropTable[Car].y1 + 1) * FontSize );

//      return KPt( (s32)((float)(m_CropTable[Car].x2 - m_CropTable[Car].x1 + 1) * m_RatioX + m_SpaceX), (s32)(m_CropTable[Car].y2 - m_CropTable[Car].y1 ) );
        return KPt( SizeX, SizeY );
}

//--------------------------------------------------------------------------------------------------------------------------
KPt KFont::GetTextSize( char* pText, float FontSize )
{
        KPt             Size( 0, 0 );
        KPt             Tmp;

        if( pText )
        {
                for( u32 i = 0; i < strlen( pText ); i ++ )
                {
                        Tmp = GetCharSize( pText[i], FontSize );
                        Size.x += Tmp.x + (s32)m_SpaceX;
                        if( Tmp.y > Size.y )
                                Size.y = Tmp.y;
                }
        }

        return Size;
}

//--------------------------------------------------------------------------------------------------------------------------
void KFont::Print( KPt& Pos, char* pText, float FontSize, KFONTALIGN FontAlign, KCOLOR Color )
{
        KASSERT( pText );

        KTLVertex                       vVertex[4];
        unsigned char           Car;
        int                                     Length = (int)strlen( pText );
        float                           Italic = 0.0f;
        KPt                                     PosOffset;
        KPt                                     CarPos = KPt( 0, 0 );

//      FontSize /= 2.0f;

        switch( FontAlign )
        {
        case KFA_LEFT:
                PosOffset = Pos;
                break;
        case KFA_RIGHT:
                PosOffset = Pos - KFont::GetTextSize( pText );
                break;
        case KFA_CENTER:
                PosOffset = Pos + (KFont::GetTextSize( pText )) / 2;
                break;
        }

        CarPos = CarPos + PosOffset;

        for(int i = 0;i < Length;i ++)
        {
                if( (u8)pText[i] < 32 )
                        continue;

                Car = pText[i];
                
                float           posx = (float)(Car % (FONT_BITMAP_WIDTH / FONT_WIDTH));
                float           posy = (float)(Car / (FONT_BITMAP_WIDTH / FONT_WIDTH));

                float           minx = (float)(posx * FONT_WIDTH)                       / FONT_BITMAP_WIDTH;
                float           maxx = (float)((posx + 1) * FONT_WIDTH)         / FONT_BITMAP_WIDTH;
                float           miny = (float)(posy * FONT_HEIGHT)                      / FONT_BITMAP_HEIGHT;
                float           maxy = (float)((posy + 1) * FONT_HEIGHT)        / FONT_BITMAP_HEIGHT;
//              float           FontWidth       = FONT_WIDTH * FontSize;
//              float           FontHeight      = FONT_HEIGHT * FontSize;
                float           dtexelu = 0.5f / FONT_BITMAP_WIDTH;
                float           dtexelv = 0.5f / FONT_BITMAP_HEIGHT;

//              m_CropTable[Car].x1 = 0;
//              m_CropTable[Car].x2 = 2;
//              minx = 0.0f;
        

                maxx = minx + (float)(m_CropTable[Car].x2+1) / FONT_BITMAP_WIDTH;
                minx += m_CropTable[Car].x1 / (float)FONT_BITMAP_WIDTH;
                
                minx += dtexelu;
                maxx += dtexelu;
                miny += dtexelv;
                maxy += dtexelv;
        
                float                   tu[4] = { minx, maxx, minx, maxx };
                float                   tv[4] = { miny, miny, maxy, maxy };

                s32     SizeX = s32( (float)(m_CropTable[Car].x2 - m_CropTable[Car].x1 + 1) * m_RatioX * FontSize );
                s32     SizeY = s32( (float)(m_CropTable[Car].y2 - m_CropTable[Car].y1 + 1) * FontSize );

                m_pRender->DrawQuad(    CarPos.x, 
                                                                PosOffset.y,
                                                                SizeX,
                                                                SizeY,
                                                                m_hShader,
                                                                Color,
                                                                KRGBA( 0, 0, 0, 0 ),
                                                                KRM_NORMAL,
                                                                tu,
                                                                tv );

                CarPos.x += SizeX + (s32)m_SpaceX;
        }

        float                   dtexel = 0.5f / FONT_BITMAP_WIDTH;
        float                   max = 1.0f + dtexel;
        float                   min = 0.0f + dtexel;
        float                   pTU[4] = {min, max, min, max};
        float                   pTV[4] = {min, min, max, max};

//      m_pRender->DrawQuad( 0, 0, FONT_BITMAP_WIDTH, FONT_BITMAP_HEIGHT, m_hShader, KRGB( 255, 255, 255 ), KRGB( 0, 0, 0 ), KRM_NORMAL, pTU, pTV );
}

---