如何在OpenGL中显示Unicode文本？

Question

有没有一种在Windows操作系统下展示OpenGL中Unicode文本的好方法？例如，当你需要处理不同语言时。最常用的方法如下：

#define FONTLISTRANGE 128
GLuint list;
list = glGenLists(FONTLISTRANGE);
wglUseFontBitmapsW(hDC, 0, FONTLISTRANGE, list);

仅仅这样做是不够的，因为您无法为所有Unicode字符创建足够的列表。

- Serge

Answer 1

您还应该查看FTGL库。

FTGL是一个免费的跨平台开源C++库，使用Freetype2简化了在OpenGL应用程序中渲染字体。 FTGL支持位图，像素图，纹理贴图，轮廓，多边形网格和挤出多边形渲染模式。

这个项目有一段时间处于休眠状态，但最近已经重新开始开发。我还没有更新我的项目以使用最新版本，但您应该看一下它。

它允许使用任何True Type字体通过FreeType字体库。

- Rob Thomas

---

嗨，我正在使用FreeType库，非常满意。现在，当我将文本呈现为曲线时，性能变得非常慢，因此我采用了字体纹理技术以实现更快的显示。但是这样做，我无法使用整个Unicode字体，因为我只呈现了有限数量的字形。在这种情况下，您有什么建议的方法吗？我主要希望支持英语和希腊语。 - user5141040

Answer 2

我建议阅读这篇OpenGL字体教程。虽然它是针对D编程语言的，但它是一个很好的介绍如何使用OpenGL实现字形缓存系统来呈现文本的教程。该教程涵盖了Unicode合规性、抗锯齿和字距技术。

如果您了解C++，那么D语言也很容易理解，而且大部分文章都是关于一般技术，而不是实现语言。

- Baxissimo

---

你的链接已失效。 - user5141040

Answer 3

我建议你像上面已经建议的那样使用FTGL。不过，我自己实现了一个FreeType/OpenGL渲染器，如果你想重复造轮子，可能会发现我的代码很有用。不过，我还是非常推荐使用FTGL，因为它使用起来更加方便。

* glTextRender class by Semi Essessi
 *
 * FreeType2 empowered text renderer
 *
 */

#include "glTextRender.h"
#include "jEngine.h"

#include "glSystem.h"

#include "jMath.h"
#include "jProfiler.h"
#include "log.h"

#include <windows.h>

FT_Library glTextRender::ftLib = 0;

//TODO::maybe fix this so it use wchar_t for the filename
glTextRender::glTextRender(jEngine* j, const char* fontName, int size = 12)
{
#ifdef _DEBUG
    jProfiler profiler = jProfiler(L"glTextRender::glTextRender");
#endif
    char fontName2[1024];
    memset(fontName2,0,sizeof(char)*1024);
    sprintf(fontName2,"fonts\\%s",fontName);

    if(!ftLib)
    {
#ifdef _DEBUG
        wchar_t fn[128];
        mbstowcs(fn,fontName,strlen(fontName)+1);
        LogWriteLine(L"\x25CB\x25CB\x25CF Font: %s was requested before FreeType was initialised", fn);
#endif
        return;
    }

    // constructor code for glTextRender
    e=j;

    gl = j->gl;

    red=green=blue=alpha=1.0f;

    face = 0;

    // remember that for some weird reason below font size 7 everything gets scrambled up
    height = max(6,(int)floorf((float)size*((float)gl->getHeight())*0.001666667f));
    aHeight = ((float)height)/((float)gl->getHeight());

    setPosition(0.0f,0.0f);

    // look in base fonts dir
    if(FT_New_Face(ftLib, fontName2, 0, &face ))
    {
        // if we dont have it look in windows fonts dir
        char buf[1024];
        GetWindowsDirectoryA(buf,1024);
        strcat(buf, "\\fonts\\");
        strcat(buf, fontName);

        if(FT_New_Face(ftLib, buf, 0, &face ))
        {
            //TODO::check in mod fonts directory
#ifdef _DEBUG
            wchar_t fn[128];
            mbstowcs(fn,fontName,strlen(fontName)+1);
            LogWriteLine(L"\x25CB\x25CB\x25CF Request for font: %s has failed", fn);
#endif
            face = 0;
            return;
        }
    }

    // FreeType uses 64x size and 72dpi for default
    // doubling size for ms 
    FT_Set_Char_Size(face, mulPow2(height,7), mulPow2(height,7), 96, 96);

    // set up cache table and then generate the first 256 chars and the console prompt character
    for(int i=0;i<65536;i++) 
    {
        cached[i]=false;
        width[i]=0.0f;
    }

    for(unsigned short i = 0; i < 256; i++) getChar((wchar_t)i);
    getChar(CHAR_PROMPT);

#ifdef _DEBUG
    wchar_t fn[128];
    mbstowcs(fn,fontName,strlen(fontName)+1);
    LogWriteLine(L"\x25CB\x25CB\x25CF Font: %s loaded OK", fn);
#endif
}

glTextRender::~glTextRender()
{
    // destructor code for glTextRender
    for(int i=0;i<65536;i++)
    {
        if(cached[i])
        {
            glDeleteLists(listID[i],1);
            glDeleteTextures(1,&(texID[i]));
        }
    }

    // TODO:: work out stupid freetype crashz0rs
    try
    {
        static int foo = 0;
        if(face && foo < 1)
        {
            foo++;
            FT_Done_Face(face);
            face = 0;
        }
    }
    catch(...)
    {
        face = 0;
    }
}


// return true if init works, or if already initialised
bool glTextRender::initFreeType()
{
    if(!ftLib)
    {
        if(!FT_Init_FreeType(&ftLib)) return true;
        else return false;
    } else return true;
}

void glTextRender::shutdownFreeType()
{
    if(ftLib)
    {
        FT_Done_FreeType(ftLib);
        ftLib = 0;
    }
}

void glTextRender::print(const wchar_t* str)
{
    // store old stuff to set start position
    glPushAttrib(GL_TRANSFORM_BIT);
    // get viewport size
    GLint viewport[4];
    glGetIntegerv(GL_VIEWPORT, viewport);

    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();

    gluOrtho2D(viewport[0],viewport[2],viewport[1],viewport[3]);
    glPopAttrib();

    float color[4];
    glGetFloatv(GL_CURRENT_COLOR, color);

    glPushAttrib(GL_LIST_BIT | GL_CURRENT_BIT  | GL_ENABLE_BIT | GL_TRANSFORM_BIT); 
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    glEnable(GL_TEXTURE_2D);
    //glDisable(GL_DEPTH_TEST);

    // set blending for AA
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glTranslatef(xPos,yPos,0.0f);

    glColor4f(red,green,blue,alpha);

    // call display lists to render text
    glListBase(0u);
    for(unsigned int i=0;i<wcslen(str);i++) glCallList(getChar(str[i]));

    // restore old states
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    glPopAttrib();

    glColor4fv(color);

    glPushAttrib(GL_TRANSFORM_BIT);
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glPopAttrib();
}

void glTextRender::printf(const wchar_t* str, ...)
{
    if(!str) return;

    wchar_t*    buf = 0;
    va_list  parg;
    va_start(parg, str);

    // allocate buffer
    int len = (_vscwprintf(str, parg)+1);
    buf = new wchar_t[len];
    if(!buf) return;
    vswprintf(buf, str, parg);
    va_end(parg);

    print(buf);

    delete[] buf;
}

GLuint glTextRender::getChar(const wchar_t c)
{
    int i = (int)c;

    if(cached[i]) return listID[i];

    // load glyph and get bitmap
    if(FT_Load_Glyph(face, FT_Get_Char_Index(face, i), FT_LOAD_DEFAULT )) return 0;

    FT_Glyph glyph;
    if(FT_Get_Glyph(face->glyph, &glyph)) return 0;

    FT_Glyph_To_Bitmap(&glyph, FT_RENDER_MODE_NORMAL, 0, 1);

    FT_BitmapGlyph bitmapGlyph = (FT_BitmapGlyph)glyph;
    FT_Bitmap& bitmap = bitmapGlyph->bitmap;

    int w = roundPow2(bitmap.width);
    int h = roundPow2(bitmap.rows);

    // convert to texture in memory
    GLubyte* texture = new GLubyte[2*w*h];

    for(int j=0;j<h;j++)
    {
        bool cond = j>=bitmap.rows;

        for(int k=0;k<w;k++)
        {
                texture[2*(k+j*w)] = 0xFFu;
                texture[2*(k+j*w)+1] = ((k>=bitmap.width)||cond) ? 0x0u : bitmap.buffer[k+bitmap.width*j];
        }
    }

    // store char width and adjust max height
    // note .5f
    float ih = 1.0f/((float)gl->getHeight());
    width[i] = ((float)divPow2(face->glyph->advance.x, 7))*ih;
    aHeight = max(aHeight,(.5f*(float)bitmap.rows)*ih);

    glPushAttrib(GL_LIST_BIT | GL_CURRENT_BIT  | GL_ENABLE_BIT | GL_TRANSFORM_BIT);

    // create gl texture
    glGenTextures(1, &(texID[i]));

    glEnable(GL_TEXTURE_2D);

    glBindTexture(GL_TEXTURE_2D, texID[i]);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, texture);

    glPopAttrib();

    delete[] texture;

    // create display list
    listID[i] = glGenLists(1);

    glNewList(listID[i], GL_COMPILE);

    glBindTexture(GL_TEXTURE_2D, texID[i]);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();

    // adjust position to account for texture padding
    glTranslatef(.5f*(float)bitmapGlyph->left, 0.0f, 0.0f);
    glTranslatef(0.0f, .5f*(float)(bitmapGlyph->top-bitmap.rows), 0.0f);

    // work out texcoords
    float tx=((float)bitmap.width)/((float)w);
    float ty=((float)bitmap.rows)/((float)h);

    // render
    // note .5f
    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f);
        glVertex2f(0.0f, .5f*(float)bitmap.rows);
        glTexCoord2f(0.0f, ty);
        glVertex2f(0.0f, 0.0f);
        glTexCoord2f(tx, ty);
        glVertex2f(.5f*(float)bitmap.width, 0.0f);
        glTexCoord2f(tx, 0.0f);
        glVertex2f(.5f*(float)bitmap.width, .5f*(float)bitmap.rows);
    glEnd();

    glPopMatrix();

    // move position for the next character
    // note extra div 2
    glTranslatef((float)divPow2(face->glyph->advance.x, 7), 0.0f, 0.0f);

    glEndList();

    // char is succesfully cached for next time
    cached[i] = true;

    return listID[i];
}

void glTextRender::setPosition(float x, float y)
{
    float fac = ((float)gl->getHeight());
    xPos = fac*x+FONT_BORDER_PIXELS; yPos = fac*(1-y)-(float)height-FONT_BORDER_PIXELS;
}

float glTextRender::getAdjustedWidth(const wchar_t* str)
{
    float w = 0.0f;

    for(unsigned int i=0;i<wcslen(str);i++)
    {
        if(cached[str[i]]) w+=width[str[i]];
        else
        {
            getChar(str[i]);
            w+=width[str[i]];
        }
    }

    return w;
}

- jheriko

Answer 4

您应该考虑使用Unicode渲染库（例如Pango）将内容渲染成位图，并将该位图放置在屏幕上或纹理中。

渲染Unicode文本并不简单。因此，您不能简单地加载64K个矩形字形并使用它。

字符可能会重叠。例如，在这个笑脸中：

( ͡° ͜ʖ ͡°)

一些代码点将附加符号堆叠在前一个字符上。请考虑来自此知名帖子的摘录：

……他来了，他邪恶的辐射毁灭了所有启示，HTML标签从你的眼中渗漏出来，像液体般的痛苦，正则表达式解析的歌曲将消灭凡人的声音，从我可以看到的领域里。你能看到它吗？ 它是多么美丽，谎言的最终扑灭全部都失去了，小马来了，他来了，他来了，怨灵弥漫着我的脸，哦，天哪，不要，不要，不要停止，角色都不是真实的，Z̯͔̩̀A̕L̘̣̭G̹̫͎̕O̞̻̱，小马来了，他来了，他来了。

更新：查看了这个Pango引擎，发现它就像香蕉、大猩猩和整个丛林的故事。首先，它依赖于Glib，因为它使用了GObjects；其次，它不能直接将内容渲染到字节缓冲区中。它有Cario和FreeType后端，因此您必须使用其中一个来呈现文本并最终导出位图。目前情况看起来不太好。

此外，如果您想将结果存储在纹理中，请在设置文本后使用pango_layout_get_pixel_extents获取渲染文本所需的矩形大小。Ink矩形是包含整个文本的矩形，其左上角位置相对于逻辑矩形的左上角位置（逻辑矩形的底线是基准线）。希望这可以帮助您。

- Calmarius

Answer 5

您可能需要在纹理内存中动态生成自己的“字形缓存”，可能需要使用某种LRU策略来避免破坏所有纹理内存。这并不像您当前的方法那样容易，但是考虑到Unicode字符的数量，这可能是唯一的方法。

- basszero

Answer 6

Queso GLC非常适合这个，我已经用它来渲染3D中的中文和西里尔字母。

http://quesoglc.sourceforge.net/

它附带的Unicode文本示例应该能让你开始。

- Andreas Müller

Answer 7

标题栏支持Unicode。我刚在Mac上尝试过，应该也适用于其他地方。如果您有（比如说）包含文本标签的一些导入数据，并且其中一些标签可能包含Unicode，您可以添加一个工具，将标签回显在标题栏中。

这不是一个很好的解决方案，但非常容易实现。

- Richard Kirk

Answer 8

你也可以按语言分组字符。根据需要加载每个语言表，当你需要切换语言时，卸载先前的语言表并加载新的语言表。

- user316

---

对于亚洲语言来说，这不是一个很好的解决方案，因为原始字符数量仍然相当庞大（几千个字形），在任何给定的GL应用程序中，您可能只会使用其中很小一部分。采用动态字形缓存方法会更好。 - Baxissimo