spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

struct SVertex
{
    D3DXVECTOR4 vPosRHW;
    DWORD iColor;
    D3DXVECTOR2 vTexCoord;
};

const DWORD FVF_CUSTOMVERTEX = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;

m_lpDevice->CreateVertexBuffer(sizoef(SVertex)*20,D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,FVF_CUSTOMVERTEX,D3DPOOL_DEFAULT,&m_lpVertexBuffer,NULL);

C-/C++-Quelltext

#pragma once

//vertex des Fontbuffers

struct SFontVertex
{
    D3DXVECTOR4   vPosRHW; //Transformierte Vertexpos

    DWORD          iColor; //Texturfarbe

    D3DXVECTOR2 vTexCoord; //Texturkoordinaten

};

//Vertexformat

const DWORD FVF_FONT = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1;

//Anzahl an Zeichen, bis gerendert wird, erstmal auf 256 beschränken

const DWORD MAX_VERTICES = 1024;

class AICE_API CFont
{
private:

    LPDIRECT3DTEXTURE9           m_lpTexture; //Bitmapfont

    LPDIRECT3DVERTEXBUFFER9 m_lpVertexBuffer; //Dynamischer Vertexbuffer

    FLOAT                   m_fCoord[256][4]; //Texturkoordinaten

    int             m_iTexWidth,m_iTexHeight; //Texturbreite /höhe

    
public:

    //Konstruktor/Destruktor

    CFont();
    ~CFont();

    //Schrift erzeugen anhand Bitmapfont + byte.dat

    BOOL Init(const char* sFontFile,char* sFontDesc,DWORD iColorKey);

    //Schrift ausgeben

    void Draw(int x,int y,const char *sText,DWORD iColor);
};

C-/C++-Quelltext

#include <aice.h>

//--------------------------------------------------------------------------------------------

//Konstruktor: Setzt startwerte

//--------------------------------------------------------------------------------------------

CFont::CFont()
{
    m_lpTexture = 0;
    m_lpVertexBuffer = 0;
}

//--------------------------------------------------------------------------------------------

//Destruktor: Gibt alles frei!

//--------------------------------------------------------------------------------------------

CFont::~CFont()
{
    if (m_lpTexture) m_lpTexture->Release();
    if (m_lpVertexBuffer) m_lpVertexBuffer->Release();
}

//--------------------------------------------------------------------------------------------

//Funktion: erzeugt die Schriftart

//--------------------------------------------------------------------------------------------

BOOL CFont::Init(const char* sFontFile,char* sFontDesc,DWORD iColorKey)
{
    CLogData clLog;

    //Textur laden

    if(FAILED(D3DXCreateTextureFromFileEx(
        CGraphic::GetSingleton().GetDevice(),
        sFontFile,
        D3DX_DEFAULT,D3DX_DEFAULT,D3DX_DEFAULT,
        0,
        D3DFMT_A8R8G8B8,
        D3DPOOL_DEFAULT,
        D3DX_FILTER_NONE,
        D3DX_FILTER_NONE,
        iColorKey,
        NULL,NULL,
        &m_lpTexture)))
    {
        clLog.AddInformation("Konnte Textur für Schrift nicht laden: ",sFontFile,INFOTYPE_FAILED);
        return FALSE;
    }

    //Datei öfnen mit Zeichenbreiten

    std::ifstream fFile(sFontDesc,std::ios::in | std::ios::binary);

    if (fFile.bad())
    {
        clLog.AddInformation("Konnte Koordinatendatei für Schrift nicht laden",sFontDesc,INFOTYPE_FAILED);
        return FALSE;
    }

    //texturhöhe holen und daraus Höhe eines zeichens berechnen

    D3DSURFACE_DESC stDesc;
    m_lpTexture->GetLevelDesc(0,&stDesc);
    m_iTexWidth = stDesc.Width;
    m_iTexHeight = stDesc.Height;

    //Alle Werte für Textturkoordinaten eintragen

    FLOAT fFontHeight = static_cast<FLOAT>(m_iTexHeight / 16);
    FLOAT fFontWidth = static_cast<FLOAT>(m_iTexWidth / 16);
    for(int i=0;i<256;i++)
    {
        //Wert lesen - 2 Byte

        int iAbsValue=0;
        fFile.read(reinterpret_cast<char*>(&iAbsValue),2);

        //In Array werte speichern, xStart,yStart,xEnd,yEnd

        int iRow = i / 16;
        int iCol = i % 16;
        m_fCoord[i][0] = iCol * fFontWidth / m_iTexWidth;
        m_fCoord[i][1] = iRow * fFontHeight / m_iTexHeight;
        m_fCoord[i][2] = (iCol * fFontWidth + iAbsValue + 2) / m_iTexWidth;
        m_fCoord[i][3] = ((iRow+1) * fFontHeight) / m_iTexHeight;
    }

    //Datei schliessen

    fFile.close();

    //Dynamischen VertexBuffer erzeugen

    if(FAILED(CGraphic::GetSingleton().GetDevice()->CreateVertexBuffer(
            MAX_VERTICES*sizeof(SFontVertex),D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY,
            FVF_FONT,D3DPOOL_DEFAULT,&m_lpVertexBuffer,NULL)))
    {
        clLog.AddInformation("Font-Klasse: Konnte Vertexbuffer nicht erzeugen!",NULL,INFOTYPE_FAILED);
        return FALSE;
    }
    
    clLog.AddInformation("Schrift erfolgreiche Erzeugt!",NULL,INFOTYPE_SUCCESS);
    return TRUE;
}

//--------------------------------------------------------------------------------------------

//Funktion: Zeichnet die Schrift mit Quads

//--------------------------------------------------------------------------------------------

void CFont::Draw(int x,int y,const char *sText,DWORD iColor)
{
    LPDIRECT3DDEVICE9 lpDevice = CGraphic::GetSingleton().GetDevice();

    //Renderstates umschalten

    lpDevice->SetRenderState(D3DRS_ALPHATESTENABLE,TRUE);
    lpDevice->SetTexture(0,m_lpTexture);
    lpDevice->SetFVF(FVF_FONT);
    lpDevice->SetStreamSource(0,m_lpVertexBuffer,0,sizeof(SFontVertex));

    //Vertexbuffer sperren

    SFontVertex *vStart = NULL;
    m_lpVertexBuffer->Lock(0,0,(VOID**)&vStart,D3DLOCK_DISCARD);

    //Für jedes Zeichen

    int iLength = static_cast<int>(strlen(sText));
    FLOAT fX = static_cast<FLOAT>(x);
    FLOAT fY = static_cast<FLOAT>(y);
    
    for(int i=0;i<iLength;i++)
    {
        //Aktuelles zeichen raussuchen

        unsigned char cCurrentChar = sText[i];

        //Texturkoordinaten raussuchen

        FLOAT tx1 = m_fCoord[cCurrentChar][0];
        FLOAT ty1 = m_fCoord[cCurrentChar][1];
        FLOAT tx2 = m_fCoord[cCurrentChar][2];
        FLOAT ty2 = m_fCoord[cCurrentChar][3];

        //Breite und Höhe des Vierecks berechnen

        FLOAT w = (tx2-tx1) * m_iTexWidth;
        FLOAT h = (ty2-ty1) * m_iTexHeight;

        //vertices einstellen

        vStart->iColor = iColor;
        vStart->vPosRHW = D3DXVECTOR4(fX,fY+h,0.0f,1.0f);
        vStart->vTexCoord = D3DXVECTOR2(tx1,ty2);
        *vStart++;

        vStart->iColor = iColor;
        vStart->vPosRHW = D3DXVECTOR4(fX,fY,0.0f,1.0f);
        vStart->vTexCoord = D3DXVECTOR2(tx1,ty1);
        *vStart++;

        vStart->iColor = iColor;
        vStart->vPosRHW = D3DXVECTOR4(fX+w,fY+h,0.0f,1.0f);
        vStart->vTexCoord = D3DXVECTOR2(tx2,ty2);
        *vStart++;

        vStart->iColor = iColor;
        vStart->vPosRHW = D3DXVECTOR4(fX+w,fY,0.0f,1.0f);
        vStart->vTexCoord = D3DXVECTOR2(tx2,ty1);
        *vStart++;

        //anfangsmarke weiterschieben

        fX += w;
    }

    //VertexBuffer wieder aufschliessen

    m_lpVertexBuffer->Unlock();

    //Rendern allet

    lpDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,iLength*2);

    //Alphablending aus

    lpDevice->SetRenderState(D3DRS_ALPHATESTENABLE,FALSE);
}