PyOpenGL利用文泉驿正黑字体显示中文字体

摘要：在NeHe的OpenGL教程第43课源代码基础上，调用文泉驿正黑字体实现中文字体的显示

在OpenGL中显示汉字一直是个麻烦的事情，很多中文书籍的文抄公乐此不疲地介绍各种方法及其在windows下的代码实现。此处不在赘述，有兴趣的可以参考下面的文章：

OpenGL点阵字体绘制终极解决方案!哈!

下面的代码是在NeHe教程第43课的基础上，添加了中文字体显示功能，原则上只要字体库支持，任何unicode字符串都是可以显示的

btw，unbutu下字体库文件位置：/usr/share/fonts/

---

16/09/14 晚补注：

在Windos下请安装PIL的替代产品pillow并相应修改

import ImageFont

为

from PIL import ImageFont

python代码：

#! /usr/bin/env python
#coding=utf-8
#   Modified from following code by T.Q. 2014
#    A quick and simple opengl font library that uses GNU freetype2, written
#    and distributed as part of a tutorial for nehe.gamedev.net.
#    Sven Olsen, 2003
#    Translated to PyOpenGL by Brian Leair, 2004
# 
#
import ImageFont
import numpy as np
from OpenGL import GL,GLU

def is_cjk(uchar):
    '''
    Checks for an unicode whether a CJK character
    '''
#    cjk = (u'u4e00',u'u9fa5')
    cjk = (u'u2e80',u'ufe4f')
    if cjk[0]<=uchar<=cjk[1]:
        return True
    else:
        return False
    
def is_ascii(uchar):
    '''
    Checks for an unicode whether a ASCII character
    '''
    ascii = (u'u0000',u'u00ff')
    if ascii[0]<=uchar<=ascii[1]:
        return True
    else:
        return False

def is_other(uchar):
    '''
    Checks for an unicode whether an ASCII or CJK character
    '''
    if not (is_cjk(uchar) or is_ascii(uchar)):
        return True
    else:
        return False
    
def nextpow2(x):
    '''
    If num isn't a power of 2, will return the next higher power of two 
    '''
    if x>=1.0:
        return np.int(2**np.ceil(np.log2(x)))    
    else:
        print "cannot convert negetive float to integer:",x

def getCharData(ft,uchar):
    '''
    '''
    # Use our helper function to get the widths of
    # the bitmap data that we will need in order to create
    # our texture.
    
    if isinstance(uchar,int):
        glyph = ft.getmask(chr(uchar))
    elif isinstance(uchar,unicode):
        if is_other(uchar):
            return [None]*5
        else:
            glyph = ft.getmask(uchar)
    elif isinstance(uchar,str):
        uchar = unicode(uchar)
        if is_other(uchar):
            return [None]*5
        else:
            glyph = ft.getmask(uchar)
    else:
        return [None]*5
    glyph_width,glyph_height = glyph.size
    # We are using PIL's wrapping for FreeType. As a result, we don't have 
    # direct access to glyph.advance or other attributes, so we add a 1 pixel pad.
    width = nextpow2(glyph_width + 1)
    height = nextpow2(glyph_height + 1)    
    # python GL will accept lists of integers or strings, but not Numeric arrays
    # so, we buildup a string for our glyph's texture from the Numeric bitmap 
    
    # Here we fill in the data for the expanded bitmap.
    # Notice that we are using two channel bitmap (one for
    # luminocity and one for alpha), but we assign
    # both luminocity and alpha to the value that we
    # find in the FreeType bitmap. 
    # We use the ?: operator so that value which we use
    # will be 0 if we are in the padding zone, and whatever
    # is the the Freetype bitmap otherwise.
    expanded_data = ""
    for j in xrange (height):
        for i in xrange (width):
            if (i >= glyph_width) or (j >= glyph_height):
                value = chr(0)
                expanded_data += value
                expanded_data += value
            else:
                value = chr(glyph.getpixel((i, j)))
                expanded_data += value
                expanded_data += value
    
    return glyph_width,glyph_height,width,height,expanded_data
    
def make_dlist(ft,ch,list_base,tex_base_list,color=[0,1,0]):
    '''
    Given an integer char code, build a GL texture into texture_array,
    build a GL display list for display list number display_list_base + ch.
    Populate the glTexture for the integer ch and construct a display
    list that renders the texture for ch.
    Note, that display_list_base and texture_base are supposed
    to be preallocated for 256 consecutive display lists and and 
    array of textures.
    '''
    # Load char data
    glyph_width,glyph_height,width,height,expanded_data = getCharData(ft,ch)
    if not glyph_
        return
    # -------------- Build the gl texture ------------
        
    # Now we just setup some texture paramaters.
    ID = GL.glGenTextures(1)
    tex_base_list[ch] = ID
    GL.glBindTexture(GL.GL_TEXTURE_2D, ID)
    GL.glTexParameterf(GL.GL_TEXTURE_2D,GL.GL_TEXTURE_MAG_FILTER,GL.GL_LINEAR)
    GL.glTexParameterf(GL.GL_TEXTURE_2D,GL.GL_TEXTURE_MIN_FILTER,GL.GL_LINEAR)
        
    border = 0
    # Here we actually create the texture itself, notice
    # that we are using GL_LUMINANCE_ALPHA to indicate that
    # we are using 2 channel data.
    GL.glTexImage2D(GL.GL_TEXTURE_2D,0,GL.GL_RGBA,width,height,border,
        GL.GL_LUMINANCE_ALPHA,GL.GL_UNSIGNED_BYTE,expanded_data)
        
    # With the texture created, we don't need to expanded data anymore
    expanded_data = None
        
        
        
    # --- Build the gl display list that draws the texture for this character ---
        
    # So now we can create the display list
    GL.glNewList(list_base+ch,GL.GL_COMPILE)
        
    if ch == ord(" "):
        glyph_advance = glyph_width
        GL.glTranslatef(glyph_advance, 0, 0)
        GL.glEndList()
    else:
        GL.glBindTexture(GL.GL_TEXTURE_2D, ID)
        GL.glPushMatrix()
        
        # // first we need to move over a little so that
        # // the character has the right amount of space
        # // between it and the one before it.
        # glyph_left = glyph.bbox [0]
        # glTranslatef(glyph_left, 0, 0)
        
        # // Now we move down a little in the case that the
        # // bitmap extends past the bottom of the line 
        # // this is only true for characters like 'g' or 'y'.
        # glyph_descent = glyph.decent
        # glTranslatef(0, glyph_descent, 0)
        
        # //Now we need to account for the fact that many of
        # //our textures are filled with empty padding space.
        # //We figure what portion of the texture is used by 
        # //the actual character and store that information in 
        # //the x and y variables, then when we draw the
        # //quad, we will only reference the parts of the texture
        # //that we contain the character itself.
        x = np.float(glyph_width)/np.float(width)
        y = np.float(glyph_height)/np.float(height)
        
        # //Here we draw the texturemaped quads.
        # //The bitmap that we got from FreeType was not 
        # //oriented quite like we would like it to be,
        # //so we need to link the texture to the quad
        # //so that the result will be properly aligned.
        GL.glBegin(GL.GL_QUADS)
        GL.glColor3fv(color)
        GL.glTexCoord2f(0,0), GL.glVertex2f(0,glyph_height)
        GL.glTexCoord2f(0,y), GL.glVertex2f(0,0)
        GL.glTexCoord2f(x,y), GL.glVertex2f(glyph_width,0)
        GL.glTexCoord2f(x,0), GL.glVertex2f(glyph_width, glyph_height)
        GL.glEnd()
        GL.glPopMatrix()
        
        # Note, PIL's FreeType interface hides the advance from us.
        # Normal PIL clients are rendering an entire string through FreeType, not
        # a single character at a time like we are doing here.
        # Because the advance value is hidden from we will advance
        # the "pen" based upon the rendered glyph's width. This is imperfect.
        GL.glTranslatef(glyph_width + 0.75, 0, 0)
        
        # //increment the raster position as if we were a bitmap font.
        # //(only needed if you want to calculate text length)
        # //glBitmap(0,0,0,0,face->glyph->advance.x >> 6,0,NULL)
        
        # //Finnish the display list
        GL.glEndList()
    return

def dispCJK(ft,uchar,tex_base_list,color=[1,1,0]):
    '''
    '''
    # Load char data
    glyph_width,glyph_height,width,height,expanded_data = getCharData(ft,uchar)
    if glyph_width == None:
        return            
    # -------------- Build the gl texture ------------
            
    # Now we just setup some texture paramaters.
    ID = GL.glGenTextures(1)
    tex_base_list.append(ID)
    GL.glBindTexture(GL.GL_TEXTURE_2D, ID)
    GL.glTexParameterf(GL.GL_TEXTURE_2D,GL.GL_TEXTURE_MAG_FILTER,GL.GL_LINEAR)
    GL.glTexParameterf(GL.GL_TEXTURE_2D,GL.GL_TEXTURE_MIN_FILTER,GL.GL_LINEAR)
            
    border = 0
    # Here we actually create the texture itself, notice
    # that we are using GL_LUMINANCE_ALPHA to indicate that
    # we are using 2 channel data.
    GL.glTexImage2D(GL.GL_TEXTURE_2D,0,GL.GL_RGBA,width,height,border,
        GL.GL_LUMINANCE_ALPHA,GL.GL_UNSIGNED_BYTE,expanded_data)
            
    # With the texture created, we don't need to expanded data anymore
    expanded_data = None    
    GL.glBindTexture(GL.GL_TEXTURE_2D, ID)
    GL.glPushMatrix()
    x = np.float(glyph_width)/np.float(width)
    y = np.float(glyph_height)/np.float(height)        
    GL.glBegin(GL.GL_QUADS)
    GL.glColor3fv(color)
    GL.glTexCoord2f(0,0), GL.glVertex2f(0,glyph_height)
    GL.glTexCoord2f(0,y), GL.glVertex2f(0,0)
    GL.glTexCoord2f(x,y), GL.glVertex2f(glyph_width,0)
    GL.glTexCoord2f(x,0), GL.glVertex2f(glyph_width, glyph_height)
    GL.glEnd()
    GL.glPopMatrix()
    GL.glTranslatef(glyph_width + 0.75, 0, 0)
    return


def pushScreenCoordinateMatrix():
    # A fairly straight forward function that pushes
    # a projection matrix that will make object world 
    # coordinates identical to window coordinates.    
    GL.glPushAttrib(GL.GL_TRANSFORM_BIT)
    viewport = GL.glGetIntegerv(GL.GL_VIEWPORT)
    GL.glMatrixMode(GL.GL_PROJECTION)
    GL.glPushMatrix()
    GL.glLoadIdentity()
    GLU.gluOrtho2D(viewport[0],viewport[2],viewport[1],viewport[3])
    GL.glPopAttrib()
    return



def pop_projection_matrix():
    # Pops the projection matrix without changing the current
    # MatrixMode.    
    GL.glPushAttrib(GL.GL_TRANSFORM_BIT)
    GL.glMatrixMode(GL.GL_PROJECTION)
    GL.glPopMatrix()
    GL.glPopAttrib()
    return

    
class font_data(object):
    '''
    '''
    def __init__(self, facename, pixel_height):
        # We haven't yet allocated textures or display lists
        self.m_allocated = False
        self.m_font_height = pixel_height
        self.m_facename = facename
        
        # Try to obtain the FreeType font
        try:
            self.ft = ImageFont.truetype (facename, pixel_height)
        except:
            raise ValueError, "Unable to locate true type font '%s'" % (facename)
        # Here we ask opengl to allocate resources for
        # all the textures and displays lists which we
        # are about to create.  
        # Note: only ASCII character
        n = 256
        self.m_list_base = GL.glGenLists(n)
        
        # Consturct a list of 256 elements. This
        # list will be assigned the texture IDs we create for each glyph
        self.textures = [None] * n
        self.cjk_textures = []
        # This is where we actually create each of the fonts display lists.
        for i in xrange(n):
            make_dlist(self.ft, i, self.m_list_base, self.textures)
        
        self.m_allocated = True
    
    def glPrint(self,x,y,string,color=[1,0,0]):
        '''
        '''
        # We want a coordinate system where things coresponding to window pixels.
        
        pushScreenCoordinateMatrix()            
        # //We make the height about 1.5* that of
        h = np.float(self.m_font_height)/0.63
        
        if not string:
            pop_projection_matrix()
            return
        else:
            if not isinstance(string,unicode):
                try:
                    string = unicode(string)
                except:
                    raise ValueError,"Can not convert to unicode",string
            # //Here is some code to split the text that we have been
            # //given into a set of lines.  
            # //This could be made much neater by using
            # //a regular expression library such as the one avliable from
            # //boost.org (I've only done it out by hand to avoid complicating
            # //this tutorial with unnecessary library dependencies).
            # //Note: python string object has convenience method for this :)
            lines = string.split("
")
            GL.glPushAttrib(GL.GL_LIST_BIT|GL.GL_CURRENT_BIT |GL.GL_ENABLE_BIT|GL.GL_TRANSFORM_BIT)
            GL.glMatrixMode(GL.GL_MODELVIEW)
#            GL.glDisable(GL.GL_LIGHTING)
#            GL.glEnable(GL.GL_TEXTURE_2D)
#            GL.glDisable(GL.GL_DEPTH_TEST)
#            GL.glEnable(GL.GL_BLEND)
#            GL.glBlendFunc(GL.GL_SRC_ALPHA,GL.GL_ONE_MINUS_SRC_ALPHA)
            
            GL.glListBase(self.m_list_base)
            modelview_matrix = GL.glGetFloatv(GL.GL_MODELVIEW_MATRIX)
            
            # //This is where the text display actually happens.
            # //For each line of text we reset the modelview matrix
            # //so that the line's text will start in the correct position.
            # //Notice that we need to reset the matrix, rather than just translating
            # //down by h. This is because when each character is
            # //draw it modifies the current matrix so that the next character
            # //will be drawn immediatly after it.  
            for i in xrange(len(lines)):
                line = lines[i]
                GL.glPushMatrix()
                GL.glLoadIdentity ()
                GL.glTranslatef(x,y-h*i,0);
                GL.glMultMatrixf(modelview_matrix);
            
                # //  The commented out raster position stuff can be useful if you need to
                # //  know the length of the text that you are creating.
                # //  If you decide to use it make sure to also uncomment the glBitmap command
                # //  in make_dlist().
                # //    glRasterPos2f(0,0);
                #            glCallLists (line)
                for tt in line:
                    if is_cjk(tt):
                        dispCJK(self.ft,tt,self.cjk_textures)
                    else:
            #            print 'ascii',tt
                        GL.glCallList(ord(tt)+1)
                # //    rpos = glGetFloatv (GL_CURRENT_RASTER_POSITION)
                # //    float len=x-rpos[0];
                GL.glPopMatrix()
            GL.glPopAttrib()
            pop_projection_matrix()
            
            
        
    def release(self):
        """ Release the gl resources for this Face.
            (This provides the functionality of KillFont () and font_data::clean ()
        """
        if self.m_allocated:
            # Free up the glTextures and the display lists for our face
            GL.glDeleteLists( self.m_list_base, 256);
            for ID in self.textures:
                GL.glDeleteTextures(ID)
            if self.cjk_textures:
                for ID in self.cjk_textures:
                    GL.glDeleteTextures(ID)
            # Extra defensive. Clients that continue to try and use this object
            # will now trigger exceptions.
            self.list_base = None
            self.m_allocated = False
    
    def __del__ (self):
        """ Python destructor for when no more refs to this Face object """
        self.release()
    
# Unit Test harness if this python module is run directly.
if __name__=="__main__":
    print "testing availability of freetype font arial
"
    ft = ImageFont.truetype ("Test.ttf", 15)
    if ft:
        print "Found the TrueType font 'Test.ttf'"
    else:
        print "faild to find the TrueTYpe font 'arial'
"

        

#! /usr/bin/env python
#coding=utf-8
# NeHe Tutorial Lesson: 43 - FreeType fonts in OpenGL
#
# Ported to PyOpenGL 2.0 by Brian Leair 18 Jan 2004
#
# This code was created by Jeff Molofee 2000
#
# The port was based on the PyOpenGL tutorials and from 
# PyOpenGLContext (tests/glprint.py)
#
# If you've found this code useful, feel free to let me know 
# at (Brian Leair telcom_sage@yahoo.com).
#
# See original source and C based tutorial at http://nehe.gamedev.net
#
# Note:
# -----
# This code is not an ideal example of Pythonic coding or use of OO 
# techniques. It is a simple and direct exposition of how to use the 
# Open GL API in Python via the PyOpenGL package. It also uses GLUT, 
# a high quality platform independent library. Due to using these APIs, 
# this code is more like a C program using procedural programming.
#
# To run this example you will need:
# Python     - www.python.org (v 2.3 as of 1/2004)
# PyOpenGL     - pyopengl.sourceforge.net (v 2.0.1.07 as of 1/2004)
# Numeric Python    - (v.22 of "numpy" as of 1/2004) numpy.sourceforge.net
# Python Image Library    - http://www.pythonware.com/products/pil/ (v1.1.4 or later)
#
# Make sure to get versions of Numeric, PyOpenGL, and PIL to match your
# version of python.
#
#

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

# Imports specific to Lesson 43
#import glFreeType
import freeTypeFont as glFreeType 
from math import cos

import sys

# Python 2.2 defines these directly
try:
    True
except NameError:
    True = 1==1
    False = 1==0


# Some api in the chain is translating the keystrokes to this octal string
# so instead of saying: ESCAPE = 27, we use the following.
ESCAPE = '33'

# Number of the glut window.
window = 0

our_font = None

# A general OpenGL initialization function.  Sets all of the initial parameters. 
def InitGL(Width, Height):                # We call this right after our OpenGL window is created.
    global our_font
    glShadeModel(GL_SMOOTH)                # Enables Smooth Color Shading
    glClearColor(0.0, 0.0, 0.0, 0.5)    # This Will Clear The Background Color To Black
    glClearDepth(1.0)                    # Enables Clearing Of The Depth Buffer
    glEnable(GL_DEPTH_TEST)                # Enables Depth Testing
    glEnable(GL_TEXTURE_2D)                # Enables texture mapping
    glDepthFunc(GL_LEQUAL)                # The Type Of Depth Test To Do
    glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) # Really Nice Perspective Calculations

    # Currently omitting the wgl based font. See lesson13.py for example use of wgl font.
    # FYI, the ttf font file "Test.ttf" in lesson43 is the typeface "Arial Black Italic".
    # our_font = glFreeType.font_data ("ARBLI___.ttf", 16)
    # our_font = glFreeType.font_data ("Test.ttf", 16)
    our_font = glFreeType.font_data("wqy-zenhei.ttc",20)
    return True
    


# The function called when our window is resized (which shouldn't happen if you enable fullscreen, below)
def ReSizeGLScene(Width, Height):
    if Height == 0:                        # Prevent A Divide By Zero If The Window Is Too Small 
        Height = 1

    glViewport(0, 0, Width, Height)        # Reset The Current Viewport And Perspective Transformation
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    # // field of view, aspect ratio, near and far
    # This will squash and stretch our objects as the window is resized.
    gluPerspective(45.0, float(Width)/float(Height), 0.1, 100.0)

    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()

cnt1 = 0
# The main drawing function. 
def DrawGLScene():
    global cnt1
    global our_font

    # Clear The Screen And The Depth Buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()                    # Reset The View 
    # Step back (away from objects)
    glTranslatef (0.0, 0.0, -1.0)

    # Currently - NYI - No WGL text
    # Blue Text
    # glColor3ub(0, 0, 0xff)
    #
    # // Position The WGL Text On The Screen
    # glRasterPos2f(-0.40f, 0.35f);
     # glPrint("Active WGL Bitmap Text With NeHe - %7.2f", cnt1);    

    # Red Text
    glColor3ub (0xff, 0, 0)

    glPushMatrix ()
    glLoadIdentity ()
    # Spin the text, rotation around z axe == will appears as a 2d rotation of the text on our screen
    glRotatef (cnt1, 0, 0, 1)
    glScalef (1, 0.8 + 0.3* cos (cnt1/5), 1)
    glTranslatef (-180, 0, 0)
    our_font.glPrint(320, 240, u"Active123中文 
FreeType Text 汉字- %7.2f
{【丯丱丳丵饕餮】}、
今日はとてもいい天気です。空は靑く" % (cnt1))
    glPopMatrix ()

    # //Uncomment this to test out print's ability to handle newlines.
    # our_font.glPrint (320, 240, "Here
there
be

newlines %f
." % (cnt1))

    cnt1 += 0.091
    # cnt2 += 0.005

    glutSwapBuffers()
    return


# The function called whenever a key is pressed. Note the use of Python tuples to pass in: (key, x, y)  
def keyPressed(*args):
    global window
    global our_font
    # If escape is pressed, kill everything.
    if args[0] == ESCAPE:
        our_font.release ()
        sys.exit()

def main():
    global window
    # pass arguments to init
    glutInit(sys.argv)

    # Select type of Display mode:   
    #  Double buffer 
    #  RGBA color
    # Alpha components supported 
    # Depth buffer
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH)
    
    # get a 640 x 480 window 
    glutInitWindowSize(640, 480)
    
    # the window starts at the upper left corner of the screen 
    glutInitWindowPosition(0, 0)
    
    # Okay, like the C version we retain the window id to use when closing, but for those of you new
    # to Python (like myself), remember this assignment would make the variable local and not global
    # if it weren't for the global declaration at the start of main.
    window = glutCreateWindow("NeHe & Sven Olsen's TrueType Font Tutorial")

       # Register the drawing function with glut, BUT in Python land, at least using PyOpenGL, we need to
    # set the function pointer and invoke a function to actually register the callback, otherwise it
    # would be very much like the C version of the code.    
    glutDisplayFunc(DrawGLScene)
    
    # Uncomment this line to get full screen.
    #glutFullScreen()

    # When we are doing nothing, redraw the scene.
    glutIdleFunc(DrawGLScene)
    
    # Register the function called when our window is resized.
    glutReshapeFunc(ReSizeGLScene)
    
    # Register the function called when the keyboard is pressed.  
    glutKeyboardFunc(keyPressed)

    # Initialize our window. 
    InitGL(640, 480)

    # Start Event Processing Engine    
    glutMainLoop()

# Print message to console, and kick off the main to get it rolling.
print "Hit ESC key to quit."
main()

Ubuntu 14.04

 

Win7