Commit 46de81b17b62211de8db7c2f8ec5702448af1f26

sammy 2008-04-13T09:28:40

* Minor refactoring in FTExtrdGlyph.cpp.

diff --git a/src/FTExtrdGlyph.cpp b/src/FTExtrdGlyph.cpp
index 7093fcc..736993d 100644
--- a/src/FTExtrdGlyph.cpp
+++ b/src/FTExtrdGlyph.cpp
@@ -41,119 +41,117 @@
 #include "FTVectoriser.h"
 
 
-FTExtrdGlyph::FTExtrdGlyph( FT_GlyphSlot glyph, float depth, bool useDisplayList)
-:   FTGlyph( glyph),
+FTExtrdGlyph::FTExtrdGlyph(FT_GlyphSlot glyph, float depth, bool useDisplayList)
+:   FTGlyph(glyph),
     glList(0)
 {
-    bBox.SetDepth( -depth);
+    bBox.SetDepth(-depth);
         
-    if( ft_glyph_format_outline != glyph->format)
+    if(ft_glyph_format_outline != glyph->format)
     {
         err = 0x14; // Invalid_Outline
         return;
     }
 
-    FTVectoriser vectoriser( glyph);
-    if( ( vectoriser.ContourCount() < 1) || ( vectoriser.PointCount() < 3))
+    FTVectoriser vectoriser(glyph);
+    if((vectoriser.ContourCount() < 1) || (vectoriser.PointCount() < 3))
     {
         return;
     }
 
-    unsigned int tesselationIndex;
-    
     if(useDisplayList)
     {
         glList = glGenLists(1);
-        glNewList( glList, GL_COMPILE);
+        glNewList(glList, GL_COMPILE);
     }
 
-    vectoriser.MakeMesh( 1.0);
+    vectoriser.MakeMesh(1.0);
     glNormal3d(0.0, 0.0, 1.0);
     
-    unsigned int horizontalTextureScale = glyph->face->size->metrics.x_ppem * 64;
-    unsigned int verticalTextureScale = glyph->face->size->metrics.y_ppem * 64;        
+    unsigned int hscale = glyph->face->size->metrics.x_ppem * 64;
+    unsigned int vscale = glyph->face->size->metrics.y_ppem * 64;        
     
     const FTMesh* mesh = vectoriser.GetMesh();
-    for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
+    for(unsigned int j = 0; j < mesh->TesselationCount(); ++j)
     {
-        const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
+        const FTTesselation* subMesh = mesh->Tesselation(j);
         unsigned int polyonType = subMesh->PolygonType();
 
-        glBegin( polyonType);
-            for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+        glBegin(polyonType);
+            for(unsigned int i = 0; i < subMesh->PointCount(); ++i)
             {
-                FTPoint point = subMesh->Point(pointIndex);
+                FTPoint pt = subMesh->Point(i);
 
-                glTexCoord2f( point.X() / horizontalTextureScale,
-                              point.Y() / verticalTextureScale);
+                glTexCoord2f(pt.X() / hscale,
+                             pt.Y() / vscale);
                 
-                glVertex3f( point.X() / 64.0f,
-                            point.Y() / 64.0f,
-                            0.0f);
+                glVertex3f(pt.X() / 64.0f,
+                           pt.Y() / 64.0f,
+                           0.0f);
             }
         glEnd();
     }
     
-    vectoriser.MakeMesh( -1.0);
+    vectoriser.MakeMesh(-1.0);
     glNormal3d(0.0, 0.0, -1.0);
     
     mesh = vectoriser.GetMesh();
-    for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
+    for(unsigned int j = 0; j < mesh->TesselationCount(); ++j)
     {
-        const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
+        const FTTesselation* subMesh = mesh->Tesselation(j);
         unsigned int polyonType = subMesh->PolygonType();
 
-        glBegin( polyonType);
-            for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+        glBegin(polyonType);
+            for(unsigned int i = 0; i < subMesh->PointCount(); ++i)
             {
-                FTPoint point = subMesh->Point(pointIndex);
+                FTPoint pt = subMesh->Point(i);
 
-                glTexCoord2f( subMesh->Point(pointIndex).X() / horizontalTextureScale,
-                              subMesh->Point(pointIndex).Y() / verticalTextureScale);
+                glTexCoord2f(subMesh->Point(i).X() / hscale,
+                             subMesh->Point(i).Y() / vscale);
                 
-                glVertex3f( subMesh->Point( pointIndex).X() / 64.0f,
-                            subMesh->Point( pointIndex).Y() / 64.0f,
-                            -depth);
+                glVertex3f(subMesh->Point(i).X() / 64.0f,
+                           subMesh->Point(i).Y() / 64.0f,
+                           -depth);
             }
         glEnd();
     }
     
     int contourFlag = vectoriser.ContourFlag();
     
-    for( size_t c = 0; c < vectoriser.ContourCount(); ++c)
+    for(size_t c = 0; c < vectoriser.ContourCount(); ++c)
     {
         const FTContour* contour = vectoriser.Contour(c);
-        unsigned int numberOfPoints = contour->PointCount();
+        unsigned int n = contour->PointCount();
         
-        glBegin( GL_QUAD_STRIP);
-            for( unsigned int j = 0; j <= numberOfPoints; ++j)
+        glBegin(GL_QUAD_STRIP);
+            for(unsigned int j = 0; j <= n; ++j)
             {
-                unsigned int pointIndex = ( j == numberOfPoints) ? 0 : j;
-                unsigned int nextPointIndex = ( pointIndex == numberOfPoints - 1) ? 0 : pointIndex + 1;
+                unsigned int cur = (j == n) ? 0 : j;
+                unsigned int next = (cur == n - 1) ? 0 : cur + 1;
                 
-                FTPoint point = contour->Point(pointIndex);
+                FTPoint pt = contour->Point(cur);
 
-                FTPoint normal = GetNormal( point, contour->Point(nextPointIndex));
-                if(normal != FTPoint( 0.0f, 0.0f, 0.0f))
+                FTPoint normal = GetNormal(pt, contour->Point(next));
+                if(normal != FTPoint(0.0f, 0.0f, 0.0f))
                 {                   
                     glNormal3dv(static_cast<const FTGL_DOUBLE*>(normal));
                 }
 
-                if( contourFlag & ft_outline_reverse_fill)
+                if(contourFlag & ft_outline_reverse_fill)
                 {
-                    glTexCoord2f( point.X() / horizontalTextureScale,
-                                  point.X() / verticalTextureScale);
+                    glTexCoord2f(pt.X() / hscale,
+                                 pt.X() / vscale);
                 
-                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, 0.0f);
-                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, -depth);
+                    glVertex3f(pt.X() / 64.0f, pt.Y() / 64.0f, 0.0f);
+                    glVertex3f(pt.X() / 64.0f, pt.Y() / 64.0f, -depth);
                 }
                 else
                 {
-                    glTexCoord2f( point.X() / horizontalTextureScale,
-                                  point.Y() / verticalTextureScale);
+                    glTexCoord2f(pt.X() / hscale,
+                                 pt.Y() / vscale);
                 
-                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, -depth);
-                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, 0.0f);
+                    glVertex3f(pt.X() / 64.0f, pt.Y() / 64.0f, -depth);
+                    glVertex3f(pt.X() / 64.0f, pt.Y() / 64.0f, 0.0f);
                 }
             }
         glEnd();
@@ -168,31 +166,31 @@ FTExtrdGlyph::FTExtrdGlyph( FT_GlyphSlot glyph, float depth, bool useDisplayList
 
 FTExtrdGlyph::~FTExtrdGlyph()
 {
-    glDeleteLists( glList, 1);
+    glDeleteLists(glList, 1);
 }
 
 
-const FTPoint& FTExtrdGlyph::Render( const FTPoint& pen)
+const FTPoint& FTExtrdGlyph::Render(const FTPoint& pen)
 {
-    glTranslatef( pen.X(), pen.Y(), 0);
+    glTranslatef(pen.X(), pen.Y(), 0);
     
-    if( glList)
+    if(glList)
     {
-        glCallList( glList);    
+        glCallList(glList);    
     }
     
     return advance;
 }
 
 
-FTPoint FTExtrdGlyph::GetNormal( const FTPoint &a, const FTPoint &b)
+FTPoint FTExtrdGlyph::GetNormal(const FTPoint &a, const FTPoint &b)
 {
     float vectorX = a.X() - b.X();
     float vectorY = a.Y() - b.Y();
                               
-    float length = sqrt( vectorX * vectorX + vectorY * vectorY );
+    float length = sqrt(vectorX * vectorX + vectorY * vectorY);
     
-    if( length > 0.01f)
+    if(length > 0.01f)
     {
         length = 1 / length;
     }
@@ -201,8 +199,8 @@ FTPoint FTExtrdGlyph::GetNormal( const FTPoint &a, const FTPoint &b)
         length = 0.0f;
     }
     
-    return FTPoint( -vectorY * length,
-                     vectorX * length,
-                     0.0f);
+    return FTPoint(-vectorY * length,
+                    vectorX * length,
+                    0.0f);
 }