Font.h

Zobrazit dokumentaci tohoto souboru.

#ifndef _HFONT_
#define _HFONT_

#include "main.h"
#include "structures.h"

#include <ft2build.h>
#include <freetype2/freetype/freetype.h>
#include <freetype2/freetype/ftglyph.h>
#include <freetype2/freetype/ftoutln.h>
#include <freetype2/freetype/fttrigon.h>

#include "Colorable.h"

class CFont: public CColorable {

public:

        CFont();
        CFont(const char *fileName, unsigned int size);
        ~CFont();

        void loadFont(const char *fileName, unsigned int h) { // nacteni a vytvoreni noveho fontu

                textures = new GLuint[128]; // pamet pro ID textur
                this->height = h;

                FT_Library library; // vytvoreni freetype

                // Inicializace FreeType
                if (FT_Init_FreeType(&library)) {
                        cerr << "FT_Init_Freetype failed" << endl;
                }

                FT_Face face; // informace o fontu

                // nacteni fontu ze souboru
                if (FT_New_Face(library, fileName, 0, &face)) {
                        cerr << "FT_New_Face failed" << endl;
                }

                // freetype meri velikost pisma v 1/64-nach pixelu (nevim proc :D)
                // aby font mel vysku h, musime velikost vynasobit 64 (tj. 6x posun doprava, 2^6)
                FT_Set_Char_Size(face, h << 6, h << 6, 96, 96);

                // 128 znaku = 128 display listu a textur
                listBase = glGenLists(128);
                glGenTextures(128, textures);

                // vytvorime display listy pro znaky
                for (unsigned char i = 0; i < 128; i++)
                        makeDList(face, i, listBase, textures);

                FT_Done_Face(face); // uvolneni zdroju
                FT_Done_FreeType(library);

                cout << "Font " << fileName << " loading ... success" << endl;

        }

        void clean(); // uvolneni prostredku

        void print(float x, float y, const char *ftm, ...); // vypise na obrazovku text
        void print(float x, float y, string str);

        inline int nextPowerTwo(int a) {
                int rval = 1;
                while (rval < a)
                        rval <<= 1;

                return rval;
        }
        ;

        void makeDList(FT_Face face, char ch, GLuint listBase, GLuint* texBase) {

                // nacteni glyphu pro znaky
                if (FT_Load_Glyph(face, FT_Get_Char_Index(face, ch), FT_LOAD_DEFAULT)) {
                        cerr << "FT_Load_Glyph failed" << endl;
                }

                FT_Glyph glyph;

                if (FT_Get_Glyph(face -> glyph, &glyph)) {
                        cerr << "FT_Get_Glyph failed" << endl;
                }

                // konverze glyphu na bitmapu
                FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, 0, 1);
                FT_BitmapGlyph bitmapGlyph = (FT_BitmapGlyph) glyph;

                FT_Bitmap& bitmap = bitmapGlyph->bitmap;

                int width = nextPowerTwo(bitmap.width);
                int height = nextPowerTwo(bitmap.rows);

                GLubyte* expandedData = new GLubyte[2 * width * height];

                // naplnime data

                for (int j = 0; j < height; j++) {
                        for (int i = 0; i < width; i++) {

                                expandedData[2 * (i + j * width)] = expandedData[2 * (i + j
                                                * width) + 1]
                                                = (i >= bitmap.width || j >= bitmap.rows) ? 0
                                                                : bitmap . buffer[i + bitmap . width * j];

                        }
                }

                // OGL

                glBindTexture(GL_TEXTURE_2D, texBase[(int) ch]);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

                glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0,
                                GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expandedData);

                delete[] expandedData;

                glNewList(listBase + ch, GL_COMPILE);

                glBindTexture(GL_TEXTURE_2D, texBase[(int) ch]);

                glPushMatrix();

                glTranslatef(bitmapGlyph -> left, 0, 0);
                glTranslatef(0, bitmapGlyph -> top - bitmap . rows, 0);

                float x = (float) bitmap.width / (float) width;
                float y = (float) bitmap.rows / (float) height;

                glBegin(GL_QUADS);
                glTexCoord2d(0, 0);
                glVertex2f(0, bitmap.rows);
                glTexCoord2d(0, y);
                glVertex2f(0, 0);
                glTexCoord2d(x, y);
                glVertex2f(bitmap.width, 0);
                glTexCoord2d(x, 0);
                glVertex2f(bitmap.width, bitmap.rows);
                glEnd();

                glPopMatrix();

                glTranslatef(face->glyph->advance.x >> 6, 0, 0);

                glEndList();

        }
        ;

        inline void pushScreenCoordinateMatrix() {

                glPushAttrib(GL_TRANSFORM_BIT);
                GLint viewport[4];
                glGetIntegerv(GL_VIEWPORT, viewport);

                glMatrixMode(GL_PROJECTION);
                glPushMatrix();
                glLoadIdentity();
                gluOrtho2D(viewport[0], viewport[2], viewport[1], viewport[3]);

                glPopAttrib();

        }
        ;

        inline void popProjectionMatrix() {

                glPushAttrib(GL_TRANSFORM_BIT);
                glMatrixMode(GL_PROJECTION);

                glPopMatrix();
                glPopAttrib();

        }
        ;

private:
        float height; // velikost pisma
        GLuint* textures; // textura pisma
        GLuint listBase;

};

#endif

---