Hi!
Kennt wer ne site mit tus für eine ogl font-engine?

Nö (außer nehe.gamedev.net halt wahrscheinlich), aber im Prinzip sollte das doch simpelst sein: Du lädst eine Textur mit allen Buchstaben drauf und zeichnest für jeden Buchstaben ein Quad oder zwei Triangles oder was auch immer...

Quellcode:
s1 = ((byte)c & 0xf) / 16.0;
t1 = ((byte)c >> 4) / 16.0;
s2 = s1 + 1.0/16.0;
t2 = t1 + 1.0/16.0;
x2 = x1 + 8*scale;
y2 = y1 + 8*scale;

glBindTexture(GL_TEXTURE_2D, texture);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBegin(GL_QUADS);
glTexCoord2f(s1, t1); glVertex2i(x1, y1);
glTexCoord2f(s1, t2); glVertex2i(x1, y2);
glTexCoord2f(s2, t2); glVertex2i(x2, y2);
glTexCoord2f(s2, t1); glVertex2i(x2, y1);
glEnd();


cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

statt polygone kannst du text auch mit glBitmap realisieren, dann kann man mit einem einzigen glCallLists(laenge_des_textes, GL_BYTE, zeiger_auf_den_text); den ganzen text schreiben

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Die glBitmap-Funktionen hab ich noch nie verwendet. Sie dürften langsamer sein (wegen dem wiederholten Datentransfer) und zudem nicht so flexibel wie Polygone.

CallLists kann man natürlich auch mit Polygonen verwenden, allerdings gibt es mit dem Code da ein Problem. So simpel dürfte der glCallLists-Aufruf nur aussehen, wenn du glücklicherweise die ersten 256 CallList-Indizes für die Buchstaben reservieren kannst.

Leider gibt OpenGL AFAIK keine Garantie dafür, daß CallList-Indizes von 1 an aufsteigend ausgegeben werden... es ist also recht wahrscheinlich, daß man anhand einer Look-up-Table die einzelnen Buchstaben in Calllist-Indizes umwandeln muß.

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

Zitat:

Prefect postete

Leider gibt OpenGL AFAIK keine Garantie dafür, daß CallList-Indizes von 1 an aufsteigend ausgegeben werden... es ist also recht wahrscheinlich, daß man anhand einer Look-up-Table die einzelnen Buchstaben in Calllist-Indizes umwandeln muß.

cu,
Prefect

hm, muss das den so sein ? du hast ne base-variable( unsigned int base = glGenLists(256) ) und in verbindung mit glListBase sollte das doch klappen ?!?

Mar 01 01:10:13 <voice> jo
Mar 01 01:10:40 <voice> bis dann ^^
Mar 01 01:11:20 <Archangel> jo
**** ENDING LOGGING AT Tue Mar 1 01:58:13 2005

jup, archangel hat recht, opengl garantiert, dass wenn man auf einmal mehrere listen erzeugt, dass diese aufeinanderfolgende nummern haben und mit glListBase kann man einfach die erste angeben.
zudem hat glbitmap den vorteil, dass es automatisch die rasterposition veraendern kann, dass heisst man kann mit einem einzigen aufruf (glCallList(zeiger_auf_den_string); ) eine komplette zeile ausgeben.
zudem muesste, wenn man glBitmap in eine displaylist packt die daten des bitmaps auf die serverseite uebertragen werden.

hier mal meine ganz billige glBitmap-font-klasse.
die Load-methode ist etwas schwerer zu verdauen, da sie meine cImage-klasse verwendet, die pixel in Image sind so angeordnt: 8 pixel pro byte, jede zeile byte-aligned.
das interessanteste ist wohl die Print-methode, die ganze 3 zeilen lang ist. (wobei nur 2 davon wichtig sind)
achja: typedef unsigned int UInt;

cFont.h:
Quellcode:#ifndef cFont_h
#define cFont_h

#include "cString.h"
#include "Types.h"

class cFont
{
  public:
    cFont();
    ~cFont();

    Bool Destroy();
    Bool Load (const    char* const);
    Void Print(const    char* const);
    Void Print(const cString& const);

  private:
    UInt mWidth;
    UInt mHeight;
    UInt mNumChars;
    UInt mBase;
};

#endif

cFont.cpp:
Quellcode:#include "cFont.h"
#include <windows.h>
#include <GL/gl.h>
#include <fstream.h>
#include "cImage.h"
#include "Debug.h"
#include "Log.h"

cFont::cFont() :
  mWidth   (0),
  mHeight  (0),
  mNumChars(0),
  mBase    (0)
{}

cFont::~cFont()
{
  Destroy();
}


Bool cFont::Destroy()
{
  Log("Destroying font");
  if (mBase && mNumChars)
    glDeleteLists(mBase, mNumChars);
  mWidth    = 0;
  mHeight   = 0;
  mNumChars = 0;
  mBase     = 0;
  return true;
}

Bool cFont::Load(const char* const FntFilename)
{
  Log.Ident("Loading Font");
  if (!Destroy()) return false;

  Log(cString("Processing font file: ") + FntFilename);
  if (!FntFilename)
  {
    Log.ErrorEnd("font file name invalid");
    return false;
  }
  ifstream FntFile(FntFilename);
  if (!FntFile.is_open())
  {
    Log.ErrorEnd("Opening font file failed");
    return false;
  }

  cString Filename;
  UInt    CharsPerLine = 0;

  Log.Ident();
  char    Buffer[1024];
  cString Line;
  cString Keyword;
  cString Param;
  while (!FntFile.eof())
  {
    FntFile.getline(Buffer, 1024);
    Line    = Buffer;
    Keyword = Line.Token(0);
    Param   = Line.Token(1);

    if (Keyword == "File")
    {
      Filename = Param;
      Log(cString("Filename: ") + Filename);
    }

    if (Keyword == "Width")
    {
      mWidth = Param;
      Log(cString("Font width: ") + cString(mWidth));
    }

    if (Keyword == "Height")
    {
      mHeight = Param;
      Log(cString("Font height: ") + cString(mHeight));
    }

    if (Keyword == "NumChars")
    {
      mNumChars = Param;
      Log(cString("Number of characters: ") + cString(mNumChars));
    }

    if (Keyword == "CharsPerLine")
    {
      CharsPerLine = Param;
      Log(cString("Characters per line: ") + cString(CharsPerLine));
    }
  }
  Log.IdentEnd();

  if ((Filename == "") ||
      (!mWidth) ||
      (!mHeight) ||
      (!mNumChars) ||
      (!CharsPerLine))
  {
    Log.ErrorEnd("Font file invalid");
    Destroy();
    return false;
  }

  Log("Loading font face");
  cImage ImgFont;
  if ((!ImgFont.Load(Filename)) ||
      (ImgFont.Format() != IMG_BITMAP) ||
      (ImgFont.Width() != CharsPerLine * ((mWidth + 7) & 0xfffffff8)) ||
      (ImgFont.Height() != mHeight * ((mNumChars + CharsPerLine - 1) / CharsPerLine)))
  {
    Log.ErrorEnd("Font face loading failed");
    Destroy();
    return false;
  }

  Log("Generating font");
  if ((mBase = glGenLists(mNumChars)) == 0)
  {
    Log.Error("Display list allocation failed");
    Destroy();
    return false;
  }

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glPixelStorei(GL_UNPACK_ROW_LENGTH, ImgFont.Width());
  for (UInt i = 0; i < mNumChars; i++)
  {
    glNewList(mBase + i, GL_COMPILE);
    glBitmap(
      mWidth,
      mHeight,
      0,
      mHeight,
      mWidth,
      0,
      ImgFont.Data() +
      ((mWidth + 7) >> 3) *
      (
        (i % CharsPerLine) +
        mHeight * (((mNumChars + CharsPerLine - 1) / CharsPerLine - 1) - (i / CharsPerLine)) * CharsPerLine
      )
    );
    glEndList();
  }
  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

  Log.IdentEnd();
  return true;
}

Void cFont::Print(const char* const a)
{
  glListBase(mBase);
  glCallLists(cString::Length(a), GL_UNSIGNED_BYTE, a);
  glListBase(0);
}

Void cFont::Print(const cString& const a)
{
  glListBase(mBase);
  glCallLists(a.Length(), GL_UNSIGNED_BYTE, a);
  glListBase(0);
}

<ot>
als ich die schrieb, habe ich noch jeden klassennamen mit c anfangen lassen; inzwischen mache ich das nicht mehr. habt ihr auch solche 'konventionen'?
</ot>

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

ich hab das auch mal gemacht, so wie m_ und m_i etc g_pBlabla und dieser ganze ... krams ^_^
aber inzwischen mach ich das auch nich mehr

Another1

...relaxing..atm =)
... und Schweiz suckt!

Ungarische Notation... tjaja, ich finds ganz gut, wenn man Code von anderen durchsehen muss, erkennt man schneller, was wo gespeichert wird. Aber wenn die Variablennamen gut vergeben sind, braucht man solche Prefixes (hat das was mit Prefect zu tun?!? ;-) ) nicht. Ich mach's jedenfalls net mehr. Bei Klassen schon noch...
Was ich gar nicht abkann, ist das Prefix "My", was man immer wieder im Windows-SDK antrifft (MyDialogProc) und immer häufiger im Internet (myYahoo etc). Gah!

TheTinySteini
Coder Poke646
"Don't Panic" - Hitchhiker's Guide to the Galaxy

mh... also ich versuche immer ein wenig in den Konventionen zu bleiben, sonst blickt man selber am Ende nicht mehr durch, dazu gehört für mich ein C vor die Klassendeklarationen/definitionen/wasauchimmer, ein m_ vor Klasseninterne Variablen und halt direkt vor den Variablennamen den Typenbezeichner wie i oder f oder c usw. und natürlich auch die Funktionsnamen werden sinnvoll genannt und ortographisch möglichst bestkorrekt geschrieben.

Stimmt, ListBase hab ich vergessen.

Ich verwende so Konventionen auf verschiedenen Ebenen: Dateinamen fangen je nach Subsystem mit einem Prefix an (cl_ für Client, sv_ für Server), ebenso die Funktionsnamen (CL_XXX, SV_XXX). Das macht die Orientierung in C-Code _viel_ einfacher.

Ansonsten gebe ich allen Klassennamen einen Prefix, da sie dann leichter zu finden sind. In unserer Engine gibt es z.B. Cxxx für Entity-Klassen, Nxxx für Netzwerkdaten-Klassen, Gxxx für GUI-Klassen, etc...

Ungarische Notation verwende ich in C-Code gar nicht, in C++-Code zum Teil, bei Klassenmembervariablen aber auf jeden Fall (bei Strukturmembers im allgemeinen nicht).

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.