spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// CTextOutput.h
class CTextOutput
{
public:
    CTextOutput ();
    ~CTextOutput();

    void            SetFont     (TTF_Font* Font) { m_pFont = Font; RenderText(); }
    TTF_Font*       GetFont     () { return m_pFont; }

    void            SetText     (string Text) { m_sText = Text; RenderText(); }
    string          GetText     () { return m_sText; }

    void            SetColor    (SDL_Color Color) { m_Color = Color; RenderText(); }
    SDL_Color       GetColor    () { return m_Color; }

    SDL_Surface*    GetSurface  () { return m_pSurface; }

private:

    void            RenderText  ();

    SDL_Surface*    m_pSurface;
    TTF_Font*       m_pFont;
    SDL_Color       m_Color;
    string          m_sText;

};


// CTextOutput.cpp
CTextOutput::CTextOutput ()
{
    // Zeiger sicherheitshalber NULL setzen
    m_pSurface = NULL;
    m_pFont = NULL;

    // Standardfarbe: Schwarz
    m_Color.r = 0;
    m_Color.g = 0;
    m_Color.b = 0;

    // Noch kein Text
    m_sText = "";

}

CTextOutput::~CTextOutput ()
{
    // Surface freigeben
    SDL_FreeSurface(m_pSurface);

}

void    CTextOutput::RenderText ()
{
    // Text auf Surface rendern
    m_pSurface = TTF_RenderText_Solid(m_pFont, m_sText.c_str(), m_Color);

    // Gab es Probleme?
    if(m_pSurface == NULL)
        cout << "Fehler beim Rendern der Schrift: " << TTF_GetError() << endl;
}



// Komplettes Anwendungsbeispiel:

// BEIM LADEN DES SPIELS

// Neue Schriftart laden
TTF_Font* pFont = TTF_OpenFont("MyFont.ttf", 16);

// Fehler beim Laden der Schriftart?
if(m_pFont == NULL)
{
    cout << "Fehler beim Laden der Schriftart: " << TTF_GetError() << endl;
    return -1;
}

// Schriftfarbe festlegen
SDL_Color Textcolor;
Textcolor.r = 123;
Textcolor.g = 213;
Textcolor.b = 132;

// Neues Text-Objekt
CTextOutput* pText = new CTextOutput();

// Schriftart, Text & Farbe setzen
pText->SetFont(pFont);
pText->SetText("Hallo Welt");
pText->SetColor(Textcolor);

// Position der Text-Ausgabe: (100|100)
SDL_Rect Rect;
Rect.x = 100;
Rect.y = 100;
Rect.w = pText->GetSurface()->w;
Rect.h = pText->GetSurface()->h;

// BEIM RENDERN DES SPIELS

// Text-Ausgabe auf Bildschirm zeichnen 
SDL_BlitSurface(pText->GetSurface(), NULL, m_pScreen, &Rect);

// BEIM BEENDEN DES SPIELS

// Zum Schluss Text-Objekt & Schriftart löschen
delete(pText);
TTF_CloseFont(pFont);

C-/C++-Quelltext

#ifndef _TTF_H_
#define _TTF_H_

#include <sstream>
#include "Framework.h"

class TTF
{
  public:
    enum eTextType {SOLID, SHADED, BLENDED};

    TTF  ();
    ~TTF ();

    void Load       (const string &sFilename, int Size);
    void SetPos     (float fXPos, float fYPos);
    void SetColor   (int R, int G, int B);
    void SetBGColor (int R, int G, int B);
    void SetText    (string sText);
    void SetText    (int Number);
    void SetType    (int Type);
    void SetSize    (int Size);
    void Render     ();
    void Render     (SDL_Surface *pSurface);

    SDL_Rect     GetRect      () const {return m_Rect;}
    SDL_Surface *GetSurface   () const {return m_pText;}
    SDL_Color    GetTextColor () const {return m_TextColor;}
    SDL_Color    GetBGColor   () const {return m_BGColor;}
    string       GetText      () const {return m_sText;}
    string       GetFilename  () const {return m_sFontFilename;}
    int          GetType      () const {return m_Type;}
    int          GetIntText   ();

  private:
    void RenderTextSurface ();

    TTF_Font *m_pFont;          // Zeiger des Textfonts
    SDL_Surface *m_pText;       // Zeiger des Textimages
    SDL_Surface *m_pScreen;     // Zeiger auf den Screen des Frameworks
    SDL_Rect m_Rect;            // Rect des Textes
    SDL_Color m_TextColor;      // Textfarbe
    SDL_Color m_BGColor;        // Texthintergrundfarbe
    string m_sFontFilename;     // Pfad des Fonts
    int m_Size;                 // Schriftgrösse
    int m_Type;                 // Schrifttyp
    string m_sText;             // String des Textes
    int m_Text;                 // Wenn der Text eine int-Wert ist

};

#endif

C-/C++-Quelltext

#include "TTF.h"

// Konstruktor
//
// Aufgabe: Allgemeine Initialisierung
//
TTF::TTF()
{
    // Zeiger von Screen holen
    m_pScreen = g_pFramework->GetScreen();

    // Textfarbe
    m_TextColor.r = m_TextColor.g = m_TextColor.b = 255;

    // Hintergrundfarbe
    m_BGColor.r = m_BGColor.g = m_BGColor.b = 0;

    // Schrifttyps
    m_Type = TTF::SOLID;

    // Anfangswert von m_Text (int)
    m_Text = 0;

    // Zeiger auf NULL setzen
    m_pFont = NULL;
    m_pText = NULL;

} // Konstruktor

// Destruktor
// 
// Aufgabe: Font schliessen und Speicher freigeben
//
TTF::~TTF()
{
    // Font schliessen
    if (m_pFont != NULL)
    {
        TTF_CloseFont(m_pFont);
        m_pFont = NULL;
    }
    
    // Surface freigeben
    if (m_pText)
    {
        SDL_FreeSurface(m_pText);
        m_pText = NULL;
    }

} // Destruktor

// Load
//
// Aufgabe: Font laden
//
void TTF::Load(const string &sFilename, int Size)
{
    m_sFontFilename = sFilename;
    
    // Wenn ein Font geladen ist wird er geschlossen
    if (m_pFont)
    {
        TTF_CloseFont(m_pFont);
    }
    
    // Font laden
    m_pFont = TTF_OpenFont(m_sFontFilename.c_str(), Size);

    // Bei einen Fehler wird die Anwendung beendet
    if (m_pFont == NULL)
    {
        cout << "Font konnte nicht geladen werden!" << endl;

        g_pFramework->Quit();
    }

    // Rect initialisieren
    m_Rect.x = 0;
    m_Rect.y = 0;
    m_Rect.w = 0;
    m_Rect.h = 0;

} // Load

// TextPos
//
// Aufgabe: Position des Textes festlegen
//
void TTF::SetPos(float fXPos, float fYPos)
{
    m_Rect.x = static_cast<int>(fXPos);
    m_Rect.y = static_cast<int>(fYPos);

} // SetPos

// SetColor
//
// Aufgabe: Textfarbe festlegen
//
void TTF::SetColor(int R, int G, int B)
{
    m_TextColor.r = R;
    m_TextColor.g = G;
    m_TextColor.b = B;

} // SetColor

// SetBGColor
//
// Aufgabe: Hintergrundfarbe festlegen (nur bei BLENDED)
//
void TTF::SetBGColor(int R, int G, int B)
{
    m_BGColor.r = R;
    m_BGColor.g = G;
    m_BGColor.b = B;

} // SetBGColor

// SetText
//
// Aufgabe: Text festlegen
//
void TTF::SetText(string sText)
{
    m_sText = sText;

    // Bei einen leeren String w auf 0 setzen
    if (m_sText == "")
    {
        m_Rect.w = 0;
    }

} // SetText

// SetText
//
// Aufgabe: Ein int-Wert in einen String konvertieren und Text festlegen
//
void TTF::SetText(int Number)
{
    m_Text = Number;

    // int in String konvertieren
    ostringstream Text;
    Text.clear();
    Text.str("");
    Text << Number;
    
    // Text festlegen
    TTF::SetText(Text.str());
    
} // SetText

// SetType
//
// Aufgabe: Rendertyp festlegen
//
void TTF::SetType(int Type)
{
    m_Type = Type;

} // SetType

// SetSize
//
// Aufgabe: Schriftgrösse ändern
//
void TTF::SetSize(int Size)
{
    m_Size = Size;
    TTF::Load(m_sFontFilename, m_Size);

} // SetType

// Render
// 
// Aufgabe: Text auf den Screen rendern
//
void TTF::Render()
{
    TTF::RenderTextSurface();

    // Text auf den Screen rendern
    if (m_pText)
    {
        SDL_BlitSurface(m_pText, NULL, m_pScreen, &m_Rect);
    }

} // Render

// Render
//
// Aufgabe: Text in ein Surface rendern
//
void TTF::Render(SDL_Surface *pSurface)
{
    TTF::RenderTextSurface();

    // Text in ein Surface rendern
    if (m_pText)
    {
        SDL_BlitSurface(m_pText, NULL, pSurface, &m_Rect);
    }

} // Render

// RenderTextSurface
//
// Aufgabe: Das Surface des Textes erstellen
//
void TTF::RenderTextSurface()
{
    // Text wird in das Surface gerendert
    if (m_pFont)
    {
        // Surface freigeben wenn es existiert
        if (m_pText != NULL)
        {
            SDL_FreeSurface(m_pText);
            m_pText = NULL;
        }
        // Surface erstellen
        if (m_Type == TTF::SHADED)
            m_pText = (TTF_RenderText_Shaded(m_pFont, m_sText.c_str(), m_TextColor, m_BGColor));
        else if (m_Type == TTF::BLENDED)
            m_pText = (TTF_RenderText_Blended(m_pFont, m_sText.c_str(), m_TextColor));
        else
            m_pText = (TTF_RenderText_Solid(m_pFont, m_sText.c_str(), m_TextColor));
    }
    // Rect updaten
    if (m_pText != NULL)
    {
        m_Rect.w = m_pText->w;
        m_Rect.h = m_pText->h;
    }

} // RenderTextSurface

// GetIntText
//
// Aufgabe: Gibt aus einen String die Zahlen als int zurück
//
int TTF::GetIntText() 
{
    // Aufgabe: Ein String in Int konvertieren 
    istringstream Text(m_sText);
    Text >> m_Text;

    return m_Text;

} // GetIntText