kc3-lang/ftgl/src/FTExtrdGlyph.cpp

• Show log

  Commit

• Hash : c0ac7ac6
  Author :
  Date : 2004-09-26T09:47:40
  

  Finalised texture coordinate generation code. Tidied some code.

Download

• src/FTExtrdGlyph.cpp

• #include <iostream>
  
  #include    <math.h>
  
  #include    "FTExtrdGlyph.h"
  #include    "FTVectoriser.h"
  
  
  FTExtrdGlyph::FTExtrdGlyph( FT_GlyphSlot glyph, float d)
  :   FTGlyph( glyph),
      glList(0),
      depth(d)
  {
      bBox.SetDepth( -depth);
          
      if( ft_glyph_format_outline != glyph->format)
      {
          err = 0x14; // Invalid_Outline
          return;
      }
  
      FTVectoriser vectoriser( glyph);
      if( ( vectoriser.ContourCount() < 1) || ( vectoriser.PointCount() < 3))
      {
          return;
      }
  
      unsigned int tesselationIndex;
      glList = glGenLists(1);
      glNewList( glList, GL_COMPILE);
  
          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;        
          
          const FTMesh* mesh = vectoriser.GetMesh();
          for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
          {
              const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
              unsigned int polyonType = subMesh->PolygonType();
  
              glBegin( polyonType);
                  for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
                  {
                      FTPoint point = subMesh->Point(pointIndex);
  
                      glTexCoord2f( point.x / horizontalTextureScale,
                                    point.y / verticalTextureScale);
                      
                      glVertex3f( point.x / 64.0f,
                                  point.y / 64.0f,
                                  0.0f);
                  }
              glEnd();
          }
          
          vectoriser.MakeMesh( -1.0);
          glNormal3d(0.0, 0.0, -1.0);
          
          mesh = vectoriser.GetMesh();
          for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
          {
              const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
              unsigned int polyonType = subMesh->PolygonType();
  
              glBegin( polyonType);
                  for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
                  {
                      FTPoint point = subMesh->Point(pointIndex);
  
                      glTexCoord2f( subMesh->Point(pointIndex).x / horizontalTextureScale,
                                    subMesh->Point(pointIndex).y / verticalTextureScale);
                      
                      glVertex3f( subMesh->Point( pointIndex).x / 64.0f,
                                  subMesh->Point( pointIndex).y / 64.0f,
                                  -depth);
                  }
              glEnd();
          }
          
          int contourFlag = vectoriser.ContourFlag();
          
          for( size_t c = 0; c < vectoriser.ContourCount(); ++c)
          {
              const FTContour* contour = vectoriser.Contour(c);
              unsigned int numberOfPoints = contour->PointCount();
              
              glBegin( GL_QUAD_STRIP);
                  for( unsigned int j = 0; j <= numberOfPoints; ++j)
                  {
                      unsigned int pointIndex = ( j == numberOfPoints) ? 0 : j;
                      unsigned int nextPointIndex = ( pointIndex == numberOfPoints - 1) ? 0 : pointIndex + 1;
                      
                      FTPoint point = contour->Point(pointIndex);
  
                      FTPoint normal = GetNormal( point, contour->Point(nextPointIndex));
                      glNormal3f( normal.x, normal.y, 0.0f);
                      
                      if( contourFlag & ft_outline_reverse_fill)
                      {
                          glTexCoord2f( point.x / horizontalTextureScale,
                                        point.y / verticalTextureScale);
                      
                          glVertex3f( point.x / 64.0f, point.y / 64.0f, 0.0f);
                          glVertex3f( point.x / 64.0f, point.y / 64.0f, -depth);
                      }
                      else
                      {
                          glTexCoord2f( point.x / horizontalTextureScale,
                                        point.y / verticalTextureScale);
                      
                          glVertex3f( point.x / 64.0f, point.y / 64.0f, -depth);
                          glVertex3f( point.x / 64.0f, point.y / 64.0f, 0.0f);
                      }
                  }
              glEnd();
          }
          
      glEndList();
  }
  
  
  FTExtrdGlyph::~FTExtrdGlyph()
  {
      glDeleteLists( glList, 1);
  }
  
  
  float FTExtrdGlyph::Render( const FTPoint& pen)
  {
      glTranslatef( pen.x, pen.y, 0);
      
      if( glList)
      {
          glCallList( glList);    
      }
      
      return advance;
  }
  
  
  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 );
      
      if( length > 0.0f)
      {
          length = 1 / length;
      }
      else
      {
          length = 0.0f;
      }
      
      return FTPoint( -vectorY * length,
                       vectorX * length,
                       0.0f);
  }
  
  

Download