FontStyle.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __FONTSTYLE_H__
#define __FONTSTYLE_H__

#include "X3DFontStyleNode.h"
#include "SFString.h"
#include "MFString.h"
#include "SFBool.h"
#include "SFFloat.h"

#if defined( HAVE_FREETYPE ) && defined( HAVE_FTGL )
#ifdef _MSC_VER
#pragma comment( lib, "ftgl_dynamic_MTD.lib" )
#endif
#include <FTGLTextureFont.h>
#endif

namespace H3D {

  class H3DAPI_API FontStyle : public X3DFontStyleNode {
  public:
    H3D_VALUE_EXCEPTION( string, InvalidFontStyleStyle );
    H3D_VALUE_EXCEPTION( string, InvalidFontStyleJustify );
    H3D_VALUE_EXCEPTION( string, InvalidFontStyleRenderType );

    FontStyle( Inst< SFNode   > _metadata    = 0,
               Inst< MFString > _family      = 0,
               Inst< SFBool   > _horizontal  = 0,
               Inst< MFString > _justify     = 0,
               Inst< SFString > _language    = 0,
               Inst< SFBool   > _leftToRight = 0,
               Inst< SFFloat  > _size        = 0,
               Inst< SFFloat  > _spacing     = 0,
               Inst< SFString > _style       = 0,
               Inst< SFBool   > _topToBottom = 0,
               Inst< SFString > _renderType  = 0 );
#if defined( HAVE_FREETYPE ) && defined( HAVE_FTGL )
    virtual void buildFonts();

    virtual bool isTopToBottom() {
      return topToBottom->getValue();
    }

    virtual bool isLeftToRight() {
      return leftToRight->getValue();
    }

    virtual H3DFloat getSpacing() { 
      return spacing->getValue();
    }

    virtual Alignment getAlignment() {
      if( horizontal->getValue() )
        return HORIZONTAL;
      else
        return VERTICAL;
    }
    
    virtual void renderChar( unsigned char c ) {
      char t[2];  t[0]=c; t[1]='\0';
      glPushMatrix();
      H3DFloat s = size->getValue();
      H3DFloat default_size = font->Ascender() - font->Descender();
      H3DFloat scale_factor = s / default_size;
      glScalef( scale_factor, scale_factor, scale_factor );

      if( renderType->getValue() == "TEXTURE" ) {
        glEnable( GL_TEXTURE_2D);
        glEnable( GL_ALPHA_TEST );
        glAlphaFunc (GL_GREATER, 0);
      }
      
      glNormal3f( 0, 0, 1 );
      font->Render( t );
      
      if( renderType->getValue() == "TEXTURE" ) {
        glDisable( GL_ALPHA_TEST );
        glDisable( GL_TEXTURE_2D);
      }
      glPopMatrix();
    }
    
    virtual H3DFloat ascender() {
      H3DFloat default_size = font->Ascender() - font->Descender();
      H3DFloat scale_factor = size->getValue() / default_size;
      return font->Ascender() * scale_factor;
    }

    virtual H3DFloat descender() {
      H3DFloat default_size = font->Ascender() - font->Descender();
      H3DFloat scale_factor = size->getValue() / default_size;
      return font->Descender() * scale_factor;
    }

    virtual Vec3f charDimensions( unsigned char c ) {
      
      H3DFloat default_size = font->Ascender() - font->Descender();
      H3DFloat scale_factor = size->getValue() / default_size;
      char t[2];  t[0]=c; t[1]='\0';
      float llx, lly, llz, urx, ury, urz;
      font->BBox( t, llx, lly, llz, urx, ury, urz );

      return Vec3f(font->Advance(t),
                   font->Ascender()-font->Descender(),
                   llz-urz) * scale_factor;

    }

    virtual Justification getMajorJustification();

    virtual Justification getMinorJustification();

#endif
    auto_ptr< MFString >  family;

    auto_ptr< SFBool   >  horizontal;

    auto_ptr< MFString >  justify;

    auto_ptr< SFString >  language;

    auto_ptr< SFBool   >  leftToRight;

    auto_ptr< SFFloat  >  size;

    auto_ptr< SFFloat  >  spacing;

    auto_ptr< SFString >  style;

    auto_ptr< SFBool >  topToBottom;

    auto_ptr< SFString > renderType;

    static H3DNodeDatabase database;
  protected:
#if defined( HAVE_FREETYPE ) && defined( HAVE_FTGL )
    FTFont *font;   
#endif
  };
}

#endif

---