参考nehe43教程，改造：FTPixmapGlyph.cpp

int ofNextPow2 ( int a ) 
{ 
    int rval=1; 
    while(rval<a) rval<<=1; 
    return rval; 
}
 
void FTPixmapGlyphImpl::TT(FT_Bitmap bitmap/*,FT_GlyphSlot glyph*/) 
{ 
    // prepare the texture: 
    int width  = ofNextPow2( bitmap.width /*+ border*2*/ ); 
    int height = ofNextPow2( bitmap.rows  /*+ border*2 */); 
    // ------------------------- this is fixing a bug with small type 
    // ------------------------- appearantly, opengl has trouble with 
    // ------------------------- width or height textures of 1, so we 
    // ------------------------- we just set it to 2... 
    if (width == 1) width = 2; 
    if (height == 1) height = 2;

    bool bAntiAlised = true; 
 
    // Allocate Memory For The Texture Data. 
    unsigned char* expanded_data = new unsigned char[ 2 * width * height]; 
 
    //-------------------------------- clear data: 
    for(int j=0; j <height;j++) { 
        for(int k=0; k < width; k++){ 
            expanded_data[2*(k+j*width)  ] = 255;   // every luminance pixel = 255 
            expanded_data[2*(k+j*width)+1] = 0; 
        } 
    } 

    if (bAntiAlised == true){ 
        //----------------------------------- 
        for(int j=0; j <height; j++) { 
            for(int k=0; k < width; k++){ 
                if ((k<bitmap.width) && (j<bitmap.rows)){ 
                    expanded_data[2*((k/*+border*/)+(j/*+border*/)*width)+1] = bitmap.buffer[k + bitmap.width*(j)]; 
                } 
            } 
        } 
        //----------------------------------- 
    } else { 
        //----------------------------------- 
        // true type packs monochrome info in a 
        // 1-bit format, hella funky 
        // here we unpack it: 
        unsigned char *src =  bitmap.buffer; 
        for(int j=0; j <bitmap.rows;j++) { 
            unsigned char b; 
            unsigned char *bptr =  src; 
            for(int k=0; k < bitmap.width ; k++){ 
                expanded_data[2*((k+1)+(j+1)*width)] = 255; 
                if (k%8==0){ b = (*bptr++);} 
                expanded_data[2*((k+1)+(j+1)*width) + 1] = 
                    b&0x80 ? 255 : 0; 
                b <<= 1; 
            } 
            src += bitmap.pitch; 
        } 
        //----------------------------------- 
    }    
    //Now we just setup some texture paramaters. 
    glGenTextures(1,&textureId); 
    glBindTexture( GL_TEXTURE_2D, textureId); 
//    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
//    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
    if (bAntiAlised == true){ 
        glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); 
        glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); 
    } else { 
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); 
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); 
    } 
//    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
 
    //Here we actually create the texture itself, notice 
    //that we are using GL_LUMINANCE_ALPHA to indicate that 
    //we are using 2 channel data. 
    bool b_use_mipmaps = false;  // FOR now this is fixed to false, could be an option, left in for legacy... 
    /*if (b_use_mipmaps){ 
        gluBuild2DMipmaps( 
            GL_TEXTURE_2D, GL_LUMINANCE_ALPHA, width, height, 
            GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expanded_data); 
    } else {*/ 
        glTexImage2D( GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, width, height, 
            0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, expanded_data ); 
    //} 
 
 
    //With the texture created, we don't need to expanded data anymore 
 
    delete [] expanded_data; 
} 

FTPixmapGlyphImpl::FTPixmapGlyphImpl(FT_GlyphSlot glyph) 
:   FTGlyphImpl(glyph), 
    destWidth(0), 
    destHeight(0), 
    data(0) 
{ 
    err = FT_Render_Glyph(glyph, FT_RENDER_MODE_NORMAL); 
    if(err || ft_glyph_format_bitmap != glyph->format) 
    { 
        return; 
    } 
 
    FT_Bitmap bitmap = glyph->bitmap; 
 
    TT(bitmap); //新增加的
............................................

const FTPoint& FTPixmapGlyphImpl::RenderImpl(const FTPoint& pen, 
                                             int renderMode) 
{ 
    int width  = ofNextPow2( destWidth  ); 
    int height = ofNextPow2( destHeight ); 
    float x = (float)destWidth / (float)width, y = (float)destHeight / (float)height; 
 
    glBindTexture(GL_TEXTURE_2D,textureId); 
 
    glPushMatrix(); 
    glTranslatef( pen.Xf(),0,0); 
    //glTranslatef((long)pos.Xf() >> 6,0,0); 
    glTranslatef(0, -(GLfloat)pos.Yf(),0); 
    float verts[] = { 
        0,destHeight,0, 
        destWidth,destHeight,0, 
        0,0,0, 
        destWidth,0,0 
    }; 
 
    float norm[] = { 
        0,0, 
        x,0, 
        0,y, 
        x,y 
    };
 
    glEnableClientState(GL_VERTEX_ARRAY); 
    glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
    glVertexPointer(3, GL_FLOAT, 3 * sizeof(float), verts); 
    glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(float), norm); 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 
    glDisableClientState(GL_VERTEX_ARRAY); 
    glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
 
    glPopMatrix(); 
/*    int border            = 3; 
    int visibleBorder   = 2; 
    float w = 800; 
    float h = 480; 
    double w1 = destWidth ; 
    w1 /= 800; 
 
    double h1 = destHeight; 
    h1 /= 800; 
    double x0 = -1 + pen.Xf() / 72 * w1*3; 
 
    int width  = ofNextPow2( destWidth + border*2 ); 
    int height = ofNextPow2( destHeight  + border*2 ); 
    float x = (float)destWidth / (float)width, y = (float)destHeight / (float)height; 
 
    if(data) 
    { 
        float dx, dy; 
 
        dx = floor(pen.Xf() + pos.Xf()); 
        dy = floor(pen.Yf() - pos.Yf()); 
     
        //glTranslatef( (int)(pen.Xf()) ,0,0); 
 
        float verts[12] = {0}; 
        verts[0] = x0; 
        verts[1] = 1; 
 
        verts[3] = x0 + w1; 
        verts[4] = 1; 
 
        verts[6] = x0; 
        verts[7] = 1 - h1; 
 
        verts[9] = x0 + w1; 
        verts[10] = 1 - h1; 
 
        float norm[8] = { 0 }; 
 
        norm[0] = 0; 
        norm[1] = 0; 
        norm[2] = x; 
        norm[3] = 0; 
 
        norm[4] = 0; 
        norm[5] = y; 
        norm[6] = x; 
        norm[7] = y; 
 
        glBindTexture(GL_TEXTURE_2D,textureId); 
 
        //glColor4f(1,0,0,1); 
 
        glEnableClientState(GL_VERTEX_ARRAY); 
        glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
        glVertexPointer(3, GL_FLOAT, 3 * sizeof(float), verts); 
        glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(float), norm); 
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 
        glDisableClientState(GL_VERTEX_ARRAY); 
        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
*/ 
/*      glBitmap(0, 0, 0.0f, 0.0f, dx, dy, (const GLubyte*)0); 
        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); 
        glPixelStorei(GL_UNPACK_ALIGNMENT, 2); 
 
        glDrawPixels(destWidth, destHeight, GL_LUMINANCE_ALPHA, 
                     GL_UNSIGNED_BYTE, (const GLvoid*)data); 
        glBitmap(0, 0, 0.0f, 0.0f, -dx, -dy, (const GLubyte*)0);*/ 
 //   } 
 
    return advance; 
} 
 
改造：FTPixmapFont.cpp

template <typename T>  
inline FTPoint FTPixmapFontImpl::RenderI(const T* string, const int len,  
   FTPoint position, FTPoint spacing,  
   int renderMode)  
{  
    // Protect GL_TEXTURE_2D and GL_BLEND, glPixelTransferf(), and blending  
    // functions.  
  //  glPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);  
  
    // Protect glPixelStorei() calls (made by FTPixmapGlyphImpl::RenderImpl).  
 //   glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
    glPushMatrix();
  
    glEnable(GL_BLEND);  
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  
 
    glEnable(GL_TEXTURE_2D);  
/*  
    GLfloat ftglColour[4];  
    glGetFloatv(GL_CURRENT_RASTER_COLOR, ftglColour);  
  
    glPixelTransferf(GL_RED_SCALE, ftglColour[0]);  
    glPixelTransferf(GL_GREEN_SCALE, ftglColour[1]);  
    glPixelTransferf(GL_BLUE_SCALE, ftglColour[2]);  
    glPixelTransferf(GL_ALPHA_SCALE, ftglColour[3]);  
*/  
    FTPoint tmp = FTFontImpl::Render(string, len,position, spacing, renderMode);  
    glPopMatrix();  
/*  
    glPopClientAttrib();  
    glPopAttrib();  
*/  
    return tmp;  
}