#! /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"

 #! /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()