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_width:
         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("\n")
             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\n"
     ft = ImageFont.truetype ("Test.ttf", 15)
     if ft:
         print "Found the TrueType font 'Test.ttf'"
     else:
         print "faild to find the TrueTYpe font 'arial'\n"

freeTypeFont.py

 #! /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 = '\033'

 # 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中文 \nFreeType Text 汉字- %7.2f\n{【丯丱丳丵饕餮】}、\n今日はとてもいい天気です。空は靑く" % (cnt1))
     glPopMatrix ()

     # //Uncomment this to test out print's ability to handle newlines.
     # our_font.glPrint (320, 240, "Here\nthere\nbe\n\nnewlines %f\n." % (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()

lesson43.py

Ubuntu 14.04

Win7