diff --git a/examples/osgtext3D/CMakeLists.txt b/examples/osgtext3D/CMakeLists.txt
index 27c014f22..755e35466 100644
--- a/examples/osgtext3D/CMakeLists.txt
+++ b/examples/osgtext3D/CMakeLists.txt
@@ -1,13 +1,9 @@
 #this file is automatically generated 
 
 SET(TARGET_H
-    GlyphGeometry.h
-    TextNode.h
 )
 
 SET(TARGET_SRC
-    GlyphGeometry.cpp
-    TextNode.cpp
     osgtext3D_orig.cpp
     osgtext3D_test.cpp
     osgtext3D.cpp
diff --git a/examples/osgtext3D/GlyphGeometry.cpp b/examples/osgtext3D/GlyphGeometry.cpp
index 0e3e84760..5878b97cc 100644
--- a/examples/osgtext3D/GlyphGeometry.cpp
+++ b/examples/osgtext3D/GlyphGeometry.cpp
@@ -35,32 +35,48 @@ public:
     typedef std::pair<unsigned int, unsigned int> Segment;
     typedef std::vector<Segment>  Segments;
     osg::ref_ptr<osg::Vec3Array> _vertices;
-    unsigned int _start;
-    unsigned int _count;
+    osg::ref_ptr<osg::DrawElementsUShort> _elements;
     Segments _segments;
 
-    Boundary(osg::Vec3Array* vertices, unsigned int start, unsigned int count)
+    Boundary(osg::Vec3Array* vertices, osg::PrimitiveSet* primitiveSet)
     {
-        _vertices = vertices;
-        _start = start;
-        _count = count;
-
-        if ((*_vertices)[start]==(*_vertices)[start+count-1])
+        osg::DrawArrays* drawArrays = dynamic_cast<osg::DrawArrays*>(primitiveSet);
+        if (drawArrays)
         {
-            // OSG_NOTICE<<"Boundary is a line loop"<<std::endl;
+            set(vertices, drawArrays->getFirst(), drawArrays->getCount());
         }
         else
         {
-            OSG_NOTICE<<"Boundary is not a line loop"<<std::endl;
+            osg::DrawElementsUShort* elements = dynamic_cast<osg::DrawElementsUShort*>(primitiveSet);
+            if (elements) set(vertices, elements);
         }
+    }
 
-        _segments.reserve(count-1);
-        for(unsigned int i=start; i<start+count-2; ++i)
+    void set(osg::Vec3Array* vertices, unsigned int start, unsigned int count)
+    {
+        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(osg::PrimitiveSet::POLYGON);
+        for(unsigned int i=start; i<start+count; ++i)
         {
-            _segments.push_back(Segment(i,i+1));
+            elements->push_back(i);
         }
-        _segments.push_back(Segment(start+count-2,start));
 
+        set(vertices, elements);
+    }
+
+    void set(osg::Vec3Array* vertices, osg::DrawElementsUShort* elements)
+    {
+        _vertices = vertices;
+        _elements = elements;
+
+        _segments.clear();
+
+        if (elements->empty()) return;
+
+        _segments.reserve(elements->size()-1);
+        for(unsigned int i=0; i<elements->size()-1; ++i)
+        {
+            _segments.push_back(Segment((*elements)[i],(*elements)[i+1]));
+        }
     }
 
     osg::Vec3 computeRayIntersectionPoint(const osg::Vec3& a, const osg::Vec3& an, const osg::Vec3& c, const osg::Vec3& cn)
@@ -251,7 +267,7 @@ public:
         face->setName("face");
 
         // reserve enough space in the vertex array to accomodate the vertices associated with the segments
-        new_vertices->reserve(new_vertices->size() + _segments.size()+1 + _count);
+        new_vertices->reserve(new_vertices->size() + _segments.size()+1 + _elements->size());
 
         // create vertices
         unsigned int previous_second = _segments[0].second;
@@ -259,10 +275,13 @@ public:
         unsigned int first = new_vertices->size();
         new_vertices->push_back(newPoint);
 
-        if (_segments[0].first != _start)
+        unsigned int start = (*_elements)[0];
+        unsigned int count = _elements->size();
+
+        if (_segments[0].first != start)
         {
             //OSG_NOTICE<<"We have pruned from the start"<<std::endl;
-            for(unsigned int j=_start; j<=_segments[0].first;++j)
+            for(unsigned int j=start; j<=_segments[0].first;++j)
             {
                 face->push_back(first);
             }
@@ -298,7 +317,7 @@ public:
         // fill the end of the polygon with repititions of the first index in the polygon to ensure
         // that the orignal and new boundary polygons have the same number and pairing of indices.
         // This ensures that the bevel can be created coherently.
-        while(face->size() < _count)
+        while(face->size() < count)
         {
             face->push_back(first);
         }
@@ -313,11 +332,11 @@ public:
         
         osg::DrawElementsUShort* bevel = new osg::DrawElementsUShort(GL_QUAD_STRIP);
         bevel->setName("bevel");
-        bevel->reserve(_count*2);
-        for(unsigned int i=0; i<_count; ++i)
+        bevel->reserve(count*2);
+        for(unsigned int i=0; i<count; ++i)
         {
             unsigned int vi = new_vertices->size();
-            new_vertices->push_back((*_vertices)[_start+i]);
+            new_vertices->push_back((*_vertices)[(*_elements)[i]]);
             bevel->push_back(vi);
             bevel->push_back((*face)[i]);
         }
@@ -328,6 +347,9 @@ public:
     {
         if (_segments.empty()) return;
 
+        unsigned int start = (*_elements)[0];
+        unsigned int count = _elements->size();
+
         if (geometry->getVertexArray()==0) geometry->setVertexArray(new osg::Vec3Array(*_vertices));
         osg::Vec3Array* new_vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
 
@@ -336,7 +358,7 @@ public:
         face->setName(faceName);
 
         // reserve enough space in the vertex array to accomodate the vertices associated with the segments
-        new_vertices->reserve(new_vertices->size() + _segments.size()+1 + _count);
+        new_vertices->reserve(new_vertices->size() + _segments.size()+1 + count);
 
         // create vertices
         unsigned int previous_second = _segments[0].second;
@@ -344,10 +366,10 @@ public:
         unsigned int first = new_vertices->size();
         new_vertices->push_back(newPoint);
 
-        if (_segments[0].first != _start)
+        if (_segments[0].first != start)
         {
             //OSG_NOTICE<<"We have pruned from the start"<<std::endl;
-            for(unsigned int j=_start; j<=_segments[0].first;++j)
+            for(unsigned int j=start; j<=_segments[0].first;++j)
             {
                 face->push_back(first);
             }
@@ -383,7 +405,7 @@ public:
         // fill the end of the polygon with repititions of the first index in the polygon to ensure
         // that the orignal and new boundary polygons have the same number and pairing of indices.
         // This ensures that the bevel can be created coherently.
-        while(face->size() < _count)
+        while(face->size() < count)
         {
             face->push_back(first);
         }
@@ -396,10 +418,10 @@ public:
 
         osg::DrawElementsUShort* bevel = new osg::DrawElementsUShort(GL_QUAD_STRIP);
         bevel->setName(bevelName);
-        bevel->reserve(_count*2);
-        for(unsigned int i=0; i<_count; ++i)
+        bevel->reserve(count*2);
+        for(unsigned int i=0; i<count; ++i)
         {
-            bevel->push_back(_start+i);
+            bevel->push_back((*_elements)[i]);
             bevel->push_back((*face)[i]);
         }
         geometry->addPrimitiveSet(bevel);
@@ -444,24 +466,24 @@ osg::Geometry* computeGlyphGeometry(osgText::Glyph3D* glyph, float bevelThicknes
         itr != orig_primitives.end();
         ++itr)
     {
-        osg::DrawArrays* drawArray = dynamic_cast<osg::DrawArrays*>(itr->get());
-        if (drawArray && drawArray->getMode()==GL_POLYGON)
+        if ((*itr)->getMode()==GL_POLYGON)
         {
-            Boundary boundaryInner(orig_vertices, drawArray->getFirst(), drawArray->getCount());
+            Boundary boundaryInner(orig_vertices, itr->get());
             boundaryInner.removeAllSegmentsBelowThickness(bevelThickness);
             boundaryInner.newAddBoundaryToGeometry(new_geometry, bevelThickness, "face", "bevel");
 
-            Boundary boundaryOuter(orig_vertices, drawArray->getFirst(), drawArray->getCount());
+            Boundary boundaryOuter(orig_vertices, itr->get());
             boundaryOuter.removeAllSegmentsAboveThickness(-shellThickness);
             boundaryOuter.newAddBoundaryToGeometry(new_geometry, -shellThickness, "", "shell");
         }
+        
     }
 
     osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(new_geometry->getVertexArray());
 
     // need to tessellate the inner boundary
     {
-        osg::Geometry* face_geometry = new osg::Geometry;
+        osg::ref_ptr<osg::Geometry> face_geometry = new osg::Geometry;
         face_geometry->setVertexArray(vertices);
 
         osg::CopyOp copyop(osg::CopyOp::DEEP_COPY_ALL);
@@ -510,6 +532,123 @@ osg::Geometry* computeGlyphGeometry(osgText::Glyph3D* glyph, float bevelThicknes
     return new_geometry.release();
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// computeTextGeometry
+//
+osg::Geometry* computeTextGeometry(osgText::Glyph3D* glyph, float width)
+{
+    osg::Vec3Array* orig_vertices = glyph->getRawVertexArray();
+    osg::Geometry::PrimitiveSetList& orig_primitives = glyph->getRawFacePrimitiveSetList();
+
+    osg::ref_ptr<osg::Geometry> text_geometry = new osg::Geometry;
+    osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array((*orig_vertices));
+
+    text_geometry->setVertexArray(vertices.get());
+    text_geometry->setPrimitiveSetList(orig_primitives);
+
+    osgUtil::Tessellator ts;
+    ts.setWindingType(osgUtil::Tessellator::TESS_WINDING_POSITIVE);
+    ts.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY);
+    ts.retessellatePolygons(*text_geometry);
+
+    osg::TriangleIndexFunctor<CollectTriangleIndicesFunctor> ctif;
+    text_geometry->accept(ctif);
+    CollectTriangleIndicesFunctor::Indices& indices = ctif._indices;
+
+    // remove the previous primitive sets
+    text_geometry->getPrimitiveSetList().clear();
+
+    if (indices.empty()) return 0;
+
+
+    // create a front face using triangle indices
+    osg::DrawElementsUShort* frontFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    frontFace->setName("face");
+    text_geometry->addPrimitiveSet(frontFace);
+    for(unsigned int i=0; i<indices.size();++i)
+    {
+        frontFace->push_back(indices[i]);
+    }
+
+    typedef std::vector<unsigned int> Indices;
+    const unsigned int NULL_VALUE = UINT_MAX;
+    Indices back_indices;
+    back_indices.resize(vertices->size(), NULL_VALUE);
+    osg::Vec3 forward(0,0,-width);
+
+    // build up the vertices primitives for the back face, and record the indices
+    // for later use, and to ensure sharing of vertices in the face primitive set
+    // the order of the triangle indices are flipped to make sure that the triangles are back face
+    osg::DrawElementsUShort* backFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    text_geometry->addPrimitiveSet(backFace);
+    for(unsigned int i=0; i<indices.size()-2;)
+    {
+        unsigned int p1 = indices[i++];
+        unsigned int p2 = indices[i++];
+        unsigned int p3 = indices[i++];
+        if (back_indices[p1]==NULL_VALUE)
+        {
+            back_indices[p1] = vertices->size();
+            vertices->push_back((*vertices)[p1]+forward);
+        }
+
+        if (back_indices[p2]==NULL_VALUE)
+        {
+            back_indices[p2] = vertices->size();
+            vertices->push_back((*vertices)[p2]+forward);
+        }
+
+        if (back_indices[p3]==NULL_VALUE)
+        {
+            back_indices[p3] = vertices->size();
+            vertices->push_back((*vertices)[p3]+forward);
+        }
+
+        backFace->push_back(back_indices[p1]);
+        backFace->push_back(back_indices[p3]);
+        backFace->push_back(back_indices[p2]);
+    }
+
+    unsigned int orig_size = orig_vertices->size();
+    Indices frontedge_indices, backedge_indices;
+    frontedge_indices.resize(orig_size, NULL_VALUE);
+    backedge_indices.resize(orig_size, NULL_VALUE);
+
+
+    for(osg::Geometry::PrimitiveSetList::iterator itr = orig_primitives.begin();
+        itr != orig_primitives.end();
+        ++itr)
+    {
+        osg::DrawElementsUShort* edging = new osg::DrawElementsUShort(osg::PrimitiveSet::QUAD_STRIP);
+        text_geometry->addPrimitiveSet(edging);
+
+        osg::DrawElementsUShort* elements = dynamic_cast<osg::DrawElementsUShort*>(itr->get());
+        if (elements)
+        {
+            for(unsigned int i=0; i<elements->size(); ++i)
+            {
+                unsigned int ei = (*elements)[i];
+                if (frontedge_indices[ei]==NULL_VALUE)
+                {
+                    frontedge_indices[ei] = vertices->size();
+                    vertices->push_back((*orig_vertices)[ei]);
+                }
+                if (backedge_indices[ei]==NULL_VALUE)
+                {
+                    backedge_indices[ei] = vertices->size();
+                    vertices->push_back((*orig_vertices)[ei]+forward);
+                }
+
+                edging->push_back(backedge_indices[ei]);
+                edging->push_back(frontedge_indices[ei]);
+            }
+        }
+    }
+
+    return text_geometry.release();
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////
 //
 // computeTextGeometry
diff --git a/examples/osgtext3D/GlyphGeometry.h b/examples/osgtext3D/GlyphGeometry.h
index 70545d89a..318a4da02 100644
--- a/examples/osgtext3D/GlyphGeometry.h
+++ b/examples/osgtext3D/GlyphGeometry.h
@@ -22,6 +22,8 @@ namespace osgText
 
 extern osg::Geometry* computeGlyphGeometry(osgText::Glyph3D* glyph, float bevelThickness, float shellThickness);
 
+extern osg::Geometry* computeTextGeometry(osgText::Glyph3D* glyph, float width);
+
 extern osg::Geometry* computeTextGeometry(osg::Geometry* glyphGeometry, const Bevel& profile, float width);
 
 extern osg::Geometry* computeShellGeometry(osg::Geometry* glyphGeometry, const Bevel& profile, float width);
diff --git a/examples/osgtext3D/TextNode.cpp b/examples/osgtext3D/TextNode.cpp
index d64744da1..4b0aff02c 100644
--- a/examples/osgtext3D/TextNode.cpp
+++ b/examples/osgtext3D/TextNode.cpp
@@ -335,6 +335,14 @@ void TextTechnique::addCharacter(const osg::Vec3& position, const osg::Vec3& siz
     }
     else
     {
+        osg::ref_ptr<osg::Geometry> textGeometry = osgText::computeTextGeometry(glyph, width);
+        if (textGeometry.valid()) geode->addDrawable(textGeometry.get());
+
+        // create the normals
+        if (smooth && textGeometry.valid())
+        {
+            osgUtil::SmoothingVisitor::smooth(*textGeometry, osg::DegreesToRadians(creaseAngle));
+        }
     }
 
     transform->addChild(geode.get());
diff --git a/examples/osgtext3D/osgtext3D.cpp b/examples/osgtext3D/osgtext3D.cpp
index 244bb6ff1..224ed1cb1 100644
--- a/examples/osgtext3D/osgtext3D.cpp
+++ b/examples/osgtext3D/osgtext3D.cpp
@@ -23,7 +23,6 @@
 #include <osg/TriangleIndexFunctor>
 #include <osg/PositionAttitudeTransform>
 #include <osgUtil/SmoothingVisitor>
-#include <osgText/Font3D>
 #include <osgDB/WriteFile>
 #include <osgGA/StateSetManipulator>
 #include <osgUtil/Tessellator>
@@ -31,113 +30,11 @@
 #include <osgViewer/ViewerEventHandlers>
 #include <osg/io_utils>
 
-#include "GlyphGeometry.h"
-#include "TextNode.h"
+#include <osgText/TextNode>
 
 extern int main_orig(int, char**);
 extern int main_test(int, char**);
 
-int main_experimental(osg::ArgumentParser& arguments)
-{
-    std::string fontFile("arial.ttf");
-    while(arguments.read("-f",fontFile)) {}
-
-    std::string word("This is a simple test");
-
-    while(arguments.read("--ascii"))
-    {
-        word.clear();
-        for(unsigned int c=' '; c<=127;++c)
-        {
-            word.push_back(c);
-        }
-    }
-
-    while(arguments.read("-w",word)) {}
-
-    osg::ref_ptr<osgText::Font> font = osgText::readFontFile(fontFile);
-    if (!font) return 1;
-    OSG_NOTICE<<"Read font "<<fontFile<<" font="<<font.get()<<std::endl;
-
-    bool useTessellator = true;
-    while(arguments.read("-t") || arguments.read("--tessellate")) { useTessellator = true; }
-    while(arguments.read("--no-tessellate")) { useTessellator = false; }
-
-    float thickness = 5.0;
-    while(arguments.read("--thickness",thickness)) {}
-
-    float width = 20.0;
-    while(arguments.read("--width",width)) {}
-
-    float creaseAngle = 30.0f;
-    while(arguments.read("--crease-angle",creaseAngle)) {}
-
-    OSG_NOTICE<<"creaseAngle="<<creaseAngle<<std::endl;
-
-    osgText::Bevel profile;
-    float ratio = 0.5;
-    while(arguments.read("--rounded",ratio)) { profile.roundedBevel(ratio); }
-    while(arguments.read("--rounded2",ratio)) { profile.roundedBevel2(ratio); }
-    while(arguments.read("--flat",ratio)) { profile.flatBevel(ratio); }
-
-    bool outline = false;
-    while(arguments.read("--outline")) { outline = true; }
-    while(arguments.read("--no-outline")) { outline = false; }
-
-    bool smooth = true;
-    while(arguments.read("--flat-shaded")) { smooth = false; }
-    while(arguments.read("--smooth")) { smooth = false; }
-
-    unsigned int numSamples = 10;
-    while(arguments.read("--samples", numSamples)) {}
-    font->setNumberCurveSamples(numSamples);
-
-    profile.print(std::cout);
-
-
-    osg::ref_ptr<osg::Group> group = new osg::Group;
-    osg::Vec3 position;
-
-    for(unsigned int i=0; i<word.size(); ++i)
-    {
-        osg::ref_ptr<osgText::Glyph3D> glyph = font->getGlyph3D(word[i]);
-        if (!glyph) return 1;
-
-        osg::ref_ptr<osg::PositionAttitudeTransform> transform = new osg::PositionAttitudeTransform;
-        transform->setPosition(position);
-        transform->setAttitude(osg::Quat(osg::inDegrees(90.0),osg::Vec3d(1.0,0.0,0.0)));
-
-        position.x() += glyph->getHorizontalWidth();
-
-        osg::ref_ptr<osg::Geode> geode = new osg::Geode;
-
-        osg::ref_ptr<osg::Geometry> glyphGeometry = osgText::computeGlyphGeometry(glyph.get(), thickness, width);
-        osg::ref_ptr<osg::Geometry> textGeometry = osgText::computeTextGeometry(glyphGeometry.get(), profile, width);
-        osg::ref_ptr<osg::Geometry> shellGeometry = outline ? osgText::computeShellGeometry(glyphGeometry.get(), profile, width) : 0;
-        if (textGeometry.valid()) geode->addDrawable(textGeometry.get());
-        if (shellGeometry.valid()) geode->addDrawable(shellGeometry.get());
-
-        // create the normals
-        if (smooth && textGeometry.valid())
-        {
-            osgUtil::SmoothingVisitor::smooth(*textGeometry, osg::DegreesToRadians(creaseAngle));
-        }
-
-        transform->addChild(geode.get());
-
-        group->addChild(transform.get());
-    }
-
-    std::string filename;
-    if (arguments.read("-o", filename)) osgDB::writeNodeFile(*group, filename);
-
-    osgViewer::Viewer viewer(arguments);
-    viewer.setSceneData(group.get());
-    viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
-    viewer.addEventHandler(new osgViewer::StatsHandler);
-    return viewer.run();
-}
-
 int main(int argc, char** argv)
 {
     osg::ArgumentParser arguments(&argc, argv);
@@ -150,10 +47,6 @@ int main(int argc, char** argv)
     {
         return main_orig(argc,argv);
     }
-    else if (arguments.read("--exp"))
-    {
-        return main_experimental(arguments);
-    }
 
     osgViewer::Viewer viewer(arguments);
 
@@ -184,6 +77,10 @@ int main(int argc, char** argv)
 
     style->setBevel(bevel);
 
+    // set up outline.
+    while(arguments.read("--outline",r)) { style->setOutlineRatio(r); }
+
+
     osgText::TextNode* text = new osgText::TextNode;
     text->setText(word);
     text->setFont(font.get());
diff --git a/include/osgText/Font b/include/osgText/Font
index 6f8013916..66540ddef 100644
--- a/include/osgText/Font
+++ b/include/osgText/Font
@@ -17,241 +17,16 @@
 #include <string>
 #include <istream>
 
-#include <osg/Vec2>
-#include <osg/Image>
-#include <osg/Texture2D>
-#include <osg/StateSet>
-#include <osg/buffered_value>
 #include <osg/TexEnv>
-#include <osg/Geometry>
-#include <osgDB/ReaderWriter>
-
-#include <osgText/Export>
-#include <osgText/KerningType>
+#include <osgText/Glyph>
+#include <osgDB/Options>
 
 #include <OpenThreads/Mutex>
 
 namespace osgText {
 
+// forward declare Font
 class Font;
-class Text;
-class Glyph3D;
-class GlyphTexture;
-
-class OSGTEXT_EXPORT Glyph : public osg::Image
-{
-public:
-
-    Glyph(unsigned int glyphCode);
-
-    unsigned int getGlyphCode() const { return _glyphCode; }
-
-    void setHorizontalBearing(const osg::Vec2& bearing);
-    const osg::Vec2& getHorizontalBearing() const;
-
-    void setHorizontalAdvance(float advance);
-    float getHorizontalAdvance() const;
-
-    void setVerticalBearing(const osg::Vec2& bearing);
-    const osg::Vec2& getVerticalBearing() const;
-
-    void setVerticalAdvance(float advance);
-    float getVerticalAdvance() const;
-
-    void setTexture(GlyphTexture* texture);
-    GlyphTexture* getTexture();
-    const GlyphTexture* getTexture() const;
-
-    void setTexturePosition(int posX,int posY);
-    int getTexturePositionX() const;
-    int getTexturePositionY() const;
-
-    void setMinTexCoord(const osg::Vec2& coord);
-    const osg::Vec2& getMinTexCoord() const;
-
-    void setMaxTexCoord(const osg::Vec2& coord);
-    const osg::Vec2& getMaxTexCoord() const;
-
-    void subload() const;
-
-protected:
-
-    virtual ~Glyph();
-
-    Font*                       _font;
-    unsigned int                _glyphCode;
-
-    osg::Vec2                   _horizontalBearing;
-    float                       _horizontalAdvance;
-
-    osg::Vec2                   _verticalBearing;
-    float                       _verticalAdvance;
-
-    GlyphTexture*               _texture;
-    int                         _texturePosX;
-    int                         _texturePosY;
-    osg::Vec2                   _minTexCoord;
-    osg::Vec2                   _maxTexCoord;
-
-    typedef osg::buffered_value<GLuint> GLObjectList;
-    mutable GLObjectList _globjList;
-
-};
-
-class OSGTEXT_EXPORT Glyph3D : public osg::Referenced
-{
-public:
-
-    Glyph3D(unsigned int glyphCode):
-        osg::Referenced(true),
-        _glyphCode(glyphCode),
-        _horizontalBearing(0,0),
-        _horizontalAdvance(0),
-        _verticalBearing(0,0),
-        _verticalAdvance(0)
-        {}
-
-    unsigned int getGlyphCode() const { return _glyphCode; }
-
-    void setHorizontalBearing(const osg::Vec2& bearing) { _horizontalBearing=bearing; }
-    const osg::Vec2 & getHorizontalBearing() const { return _horizontalBearing; }
-
-    void setHorizontalAdvance(float advance) { _horizontalAdvance=advance; }
-    float getHorizontalAdvance() const { return _horizontalAdvance; }
-
-    void setVerticalBearing(const osg::Vec2& bearing) {  _verticalBearing=bearing; }
-    const osg::Vec2& getVerticalBearing() const { return _verticalBearing; }
-
-    void setVerticalAdvance(float advance) { _verticalAdvance=advance; }
-    float getVerticalAdvance() const { return _verticalAdvance; }
-
-    void setBoundingBox(osg::BoundingBox & bb) { _bb=bb; }
-    const osg::BoundingBox & getBoundingBox() const { return _bb; }
-
-
-    /** Set whether to use a mutex to ensure ref() and unref() are thread safe.*/
-    virtual void setThreadSafeRefUnref(bool threadSafe);
-
-
-    void setRawVertexArray(osg::Vec3Array* vertices) { _rawVertexArray = vertices; }
-    osg::Vec3Array* getRawVertexArray() { return _rawVertexArray.get(); }
-
-    /** Get the PrimitiveSetList for the raw face which hasn't been tessellated. */
-    osg::Geometry::PrimitiveSetList & getRawFacePrimitiveSetList() { return _rawFacePrimitiveSetList; }
-
-    /** Get the PrimitiveSetList for the front face. */
-    osg::Geometry::PrimitiveSetList & getFrontPrimitiveSetList() { return _frontPrimitiveSetList; }
-    /** Get the PrimitiveSetList for the wall face. */
-    osg::Geometry::PrimitiveSetList & getWallPrimitiveSetList() { return _wallPrimitiveSetList; }
-    /** Get et the PrimitiveSetList for the back face. */
-    osg::Geometry::PrimitiveSetList & getBackPrimitiveSetList() { return _backPrimitiveSetList; }
-
-    /** Set the VertexArray of the glyph. */
-    void setVertexArray(osg::Vec3Array * va) { _vertexArray = va; }
-    /** Get the VertexArray of the glyph. */
-    osg::Vec3Array * getVertexArray() { return _vertexArray.get(); }
-    /** Set the VertexArray of the glyph. */
-    void setNormalArray(osg::Vec3Array * na) { _normalArray = na; }
-    /** Get the NormalArray for the wall face. */
-    osg::Vec3Array * getNormalArray() { return _normalArray.get(); }
-
-    float getHorizontalWidth() { return (-_horizontalBearing.x() + _horizontalAdvance); }
-    float getHorizontalHeight() { return (-_horizontalBearing.y() + _bb.yMax()); }
-    float getVerticalWidth() { return (-_verticalBearing.x() + _bb.xMax()); }
-    float getVerticalHeight() { return (-_verticalBearing.y() + _verticalAdvance); }
-
-    void setWidth(float width) { _width = width; }
-    float getWidth() { return _width; }
-
-    void setHeight(float height) { _height = height; }
-    float getHeight() { return _height; }
-
-protected:
-
-    virtual ~Glyph3D() {}
-
-    unsigned int                _glyphCode;
-
-    osg::Vec2                   _horizontalBearing;
-    float                       _horizontalAdvance;
-
-    osg::Vec2                   _verticalBearing;
-    float                       _verticalAdvance;
-
-    osg::BoundingBox            _bb;
-//        osg::Vec2                   _advance;
-
-    float _width;
-    float _height;
-
-
-    osg::ref_ptr<osg::Vec3Array> _vertexArray;
-    osg::ref_ptr<osg::Vec3Array> _normalArray;
-
-
-    osg::Geometry::PrimitiveSetList _frontPrimitiveSetList;
-    osg::Geometry::PrimitiveSetList _wallPrimitiveSetList;
-    osg::Geometry::PrimitiveSetList _backPrimitiveSetList;
-
-    osg::ref_ptr<osg::Vec3Array>    _rawVertexArray;
-    osg::Geometry::PrimitiveSetList _rawFacePrimitiveSetList;
-
-};
-
-
-class OSGTEXT_EXPORT GlyphTexture : public osg::Texture2D
-{
-public:
-
-    GlyphTexture();
-
-    const char* className() const { return "GlyphTexture"; }
-
-    /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/
-    virtual int compare(const osg::StateAttribute& rhs) const;
-
-    /** Set the margin around each glyph, to ensure that texture filtering doesn't bleed adjacent glyph's into each other.*/
-    void setGlyphImageMargin(unsigned int margin) { _margin = margin; }
-    unsigned int getGlyphImageMargin() const { return _margin; }
-
-    void setGlyphImageMarginRatio(float margin) { _marginRatio = margin; }
-    float getGlyphImageMarginRatio() const { return _marginRatio; }
-
-    bool getSpaceForGlyph(Glyph* glyph, int& posX, int& posY);
-
-    void addGlyph(Glyph* glyph,int posX, int posY);
-
-    virtual void apply(osg::State& state) const;
-
-    /** Set whether to use a mutex to ensure ref() and unref() are thread safe.*/
-    virtual void setThreadSafeRefUnref(bool threadSafe);
-
-    /** Resize any per context GLObject buffers to specified size. */
-    virtual void resizeGLObjectBuffers(unsigned int maxSize);
-
-protected:
-
-    virtual ~GlyphTexture();
-
-
-    // parameter used to compute the size and position of empty space
-    // in the texture which could accommodate new glyphs.
-    int _margin;
-    float _marginRatio;
-    int _usedY;
-    int _partUsedX;
-    int _partUsedY;
-
-    typedef std::vector< osg::ref_ptr<Glyph> > GlyphRefList;
-    typedef std::vector< const Glyph* > GlyphPtrList;
-    typedef osg::buffered_object< GlyphPtrList > GlyphBuffer;
-
-    GlyphRefList                _glyphs;
-    mutable GlyphBuffer         _glyphsToSubload;
-
-    mutable OpenThreads::Mutex  _mutex;
-
-};
 
 /** Read a font from specified file. The filename may contain a path.
   * It will search for the font file in the following places in this order: 
@@ -272,14 +47,14 @@ protected:
   * If the given file could not be found, the path part will be stripped and
   * the file will be searched again in the OS specific directories.
   */
-extern OSGTEXT_EXPORT Font* readFontFile(const std::string& filename, const osgDB::ReaderWriter::Options* userOptions = 0);
+extern OSGTEXT_EXPORT Font* readFontFile(const std::string& filename, const osgDB::Options* userOptions = 0);
 
 /** read a font from specified stream.*/
-extern OSGTEXT_EXPORT Font* readFontStream(std::istream& stream, const osgDB::ReaderWriter::Options* userOptions = 0);
+extern OSGTEXT_EXPORT Font* readFontStream(std::istream& stream, const osgDB::Options* userOptions = 0);
 
-extern OSGTEXT_EXPORT osg::ref_ptr<Font> readRefFontFile(const std::string& filename, const osgDB::ReaderWriter::Options* userOptions = 0);
+extern OSGTEXT_EXPORT osg::ref_ptr<Font> readRefFontFile(const std::string& filename, const osgDB::Options* userOptions = 0);
 
-extern OSGTEXT_EXPORT osg::ref_ptr<Font> readRefFontStream(std::istream& stream, const osgDB::ReaderWriter::Options* userOptions = 0);
+extern OSGTEXT_EXPORT osg::ref_ptr<Font> readRefFontStream(std::istream& stream, const osgDB::Options* userOptions = 0);
 
 extern OSGTEXT_EXPORT std::string findFontFile(const std::string& str);
 
diff --git a/include/osgText/TextNode b/include/osgText/TextNode
new file mode 100644
index 000000000..736322800
--- /dev/null
+++ b/include/osgText/TextNode
@@ -0,0 +1,229 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library 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
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef OSGTEXT_TEXTNODE
+#define OSGTEXT_TEXTNODE 1
+
+
+#include <osg/Group>
+#include <osg/Quat>
+#include <osgUtil/CullVisitor>
+
+#include <osgText/Font>
+#include <osgText/String>
+
+namespace osgText {
+
+// forward declare
+class TextNode;
+class Glyph;
+
+class Bevel : public osg::Object
+{
+    public:
+
+        Bevel();
+        Bevel(const Bevel& bevel, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
+
+        META_Object(osgText, Bevel)
+
+        void setBevelThickness(float thickness) { _thickness = thickness; }
+        float getBevelThickness() const { return _thickness; }
+
+        void flatBevel(float width=0.25f);
+
+        void roundedBevel(float width=0.5f, unsigned int numSteps=10);
+
+        void roundedBevel2(float width=0.5f, unsigned int numSteps=10);
+
+        typedef std::vector<osg::Vec2> Vertices;
+
+        void setVertices(const Vertices& vertices) { _vertices = vertices; }
+        Vertices& getVertices() { return _vertices; }
+        const Vertices& getVertices() const { return _vertices; }
+
+        void print(std::ostream& fout);
+
+    protected:
+
+        float           _thickness;
+        Vertices        _vertices;
+};
+
+
+class Style : public osg::Object
+{
+    public:
+
+        Style();
+        Style(const Style& style, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
+
+        META_Object(osgText, Style)
+
+        /// default Layout implementation used if no other is specified on TextNode
+        static osg::ref_ptr<Style>& getDefaultStyle();
+
+        /// NULL is no bevel
+        void setBevel(Bevel* bevel) { _bevel = bevel; }
+        const Bevel* getBevel() const { return _bevel.get(); }
+
+
+        /// 1 is the default width of the text
+        void setWidthRatio(float widthRatio) { _widthRatio = widthRatio; }
+        float getWidthRatio() const { return _widthRatio; }
+
+        /// 0 is 2D text
+        void setThicknessRatio(float thicknessRatio) { _thicknessRatio = thicknessRatio; }
+        float getThicknessRatio() const { return _thicknessRatio; }
+
+        /// 0 is off
+        void setOutlineRatio(float outlineRatio) { _outlineRatio = outlineRatio; }
+        float getOutlineRatio() const { return _outlineRatio; }
+
+        /// 1.0 is default number of samples
+        void setSampleDensity(float sd) { _sampleDensity = sd; }
+        float getSampleDensity() const { return _sampleDensity; }
+
+    protected:
+
+        osg::ref_ptr<Bevel>     _bevel;
+
+        float                   _widthRatio;
+        float                   _thicknessRatio;
+        float                   _outlineRatio;
+        float                   _sampleDensity;
+};
+
+class Layout : public osg::Object
+{
+    public:
+
+        Layout();
+        Layout(const Layout& layout, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
+
+        META_Object(osgText,Layout)
+
+        /// default Layout implementation used if no other is specified on TextNode
+        static osg::ref_ptr<Layout>& getDefaultLayout();
+
+        virtual void layout(TextNode& text) const;
+
+    protected:
+};
+
+class TextTechnique : public osg::Object
+{
+    public:
+
+        TextTechnique();
+        TextTechnique(const TextTechnique& technique, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
+
+        META_Object(osgText, TextTechnique)
+
+        TextNode* getTextNode() { return _textNode; }
+        const TextNode* getTextNode() const { return _textNode; }
+
+        /// default TextTechnique implementation used if no other is specified on TextNode
+        static osg::ref_ptr<TextTechnique>& getDefaultTextTechinque();
+
+        /// start building a new charater layout
+        virtual void start();
+
+        /// called by Layout engine to place individual characters
+        virtual void addCharacter(const osg::Vec3& position, const osg::Vec3& size, Glyph* glyph, Style* style);
+
+        /// called by Layout engine to place individual characters
+        virtual void addCharacter(const osg::Vec3& position, const osg::Vec3& size, Glyph3D* glyph, Style* style);
+
+        /// finish building new charater layout
+        virtual void finish();
+
+        /// provide traversal control
+        virtual void traverse(osg::NodeVisitor& nv);
+
+    protected:
+
+        friend class TextNode;
+
+        void setTextNode(TextNode* textNode) { _textNode = textNode; }
+
+        TextNode* _textNode;
+};
+
+class TextNode : public osg::Group
+{
+    public:
+
+        TextNode();
+        TextNode(const TextNode& text, const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
+
+        META_Node(osgText, TextNode)
+
+        virtual void traverse(osg::NodeVisitor& nv);
+
+        void setFont(Font* font) { _font = font; }
+        Font* getFont() { return _font.get(); }
+        const Font* getFont() const { return _font.get(); }
+        Font* getActiveFont() { return _font.valid() ? _font.get() : Font::getDefaultFont().get(); }
+        const Font* getActiveFont() const { return _font.valid() ? _font.get() : Font::getDefaultFont().get(); }
+
+        void setStyle(Style* style) { _style = style; }
+        Style* getStyle() { return _style.get(); }
+        const Style* getStyle() const { return _style.get(); }
+        Style* getActiveStyle() { return _style.valid() ? _style.get() : Style::getDefaultStyle().get(); }
+        const Style* getActiveStyle() const { return _style.valid() ? _style.get() : Style::getDefaultStyle().get(); }
+
+        void setLayout(Layout* layout) { _layout = layout; }
+        Layout* getLayout() { return _layout.get(); }
+        const Layout* getLayout() const { return _layout.get(); }
+        const Layout* getActiveLayout() const { return _layout.valid() ? _layout.get() : Layout::getDefaultLayout().get(); }
+
+        void setTextTechnique(TextTechnique* technique);
+        TextTechnique* getTextTechnique() { return _technique.get(); }
+        const TextTechnique* getTextTechnique() const { return _technique.get(); }
+
+        void setText(const std::string& str);
+        void setText(const String& str) { _string = str; }
+        String& getText() { return _string; }
+        const String& getText() const { return _string; }
+
+        void setPosition(const osg::Vec3d& position) { _position  = position; }
+        const osg::Vec3d& getPosition() const { return _position; }
+
+        void setRotation(const osg::Quat& rotation) { _rotation  = rotation; }
+        const osg::Quat& getRotation() const { return _rotation; }
+
+        void setCharacterSize(float characterSize) { _characterSize = characterSize; }
+        float getCharacterSize() const { return _characterSize; }
+
+        /// force a regeneration of the rendering backend required to represent the text.
+        virtual void update();
+
+    protected:
+
+        virtual ~TextNode();
+
+        osg::ref_ptr<Font>              _font;
+        osg::ref_ptr<Style>             _style;
+        osg::ref_ptr<Layout>            _layout;
+        osg::ref_ptr<TextTechnique>     _technique;
+
+        String                          _string;
+        osg::Vec3d                      _position;
+        osg::Quat                       _rotation;
+        float                           _characterSize;
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/osgPlugins/freetype/FreeTypeFont.cpp b/src/osgPlugins/freetype/FreeTypeFont.cpp
index f75aff99f..dd0f25b84 100644
--- a/src/osgPlugins/freetype/FreeTypeFont.cpp
+++ b/src/osgPlugins/freetype/FreeTypeFont.cpp
@@ -17,10 +17,9 @@
 #include <freetype/ftoutln.h>
 #include <freetype/ftbbox.h>
 
-#include <osg/Notify>  
+#include <osg/Notify>
+#include <osg/io_utils>
 #include <osgDB/WriteFile>
-#include <osgUtil/SmoothingVisitor>
-#include <osgUtil/Tessellator>
 
 namespace FreeType
 {
@@ -30,7 +29,6 @@ struct Char3DInfo
     Char3DInfo(int numSteps):
         _verts( new osg::Vec3Array ),
         _geometry( new osg::Geometry ),
-        _idx(0),
         _numSteps(numSteps),
         _maxY(-FLT_MAX),
         _maxX(-FLT_MAX),
@@ -38,21 +36,26 @@ struct Char3DInfo
         _minY(FLT_MAX),
         _coord_scale(1.0/64.0)
     {
+        _geometry->setVertexArray(_verts.get());
     }
+
     ~Char3DInfo()
     {
     }
 
+    void completeCurrentPrimitiveSet()
+    {
+        if (_currentPrimitiveSet.valid() && _currentPrimitiveSet->size()>1)
+        {
+            _geometry->addPrimitiveSet( _currentPrimitiveSet.get() );
+        }
+        _currentPrimitiveSet = 0;
+    }
+
     osg::Geometry* get()
     {
-        int len = _verts->size()-_idx;
-        if (len)
-        {
-            _geometry->addPrimitiveSet( new osg::DrawArrays( osg::PrimitiveSet::POLYGON, _idx, len ) );
-            _idx = _verts->size();
-        }
+        completeCurrentPrimitiveSet();
 
-        _geometry->setVertexArray(_verts.get());
         return _geometry.get();
     }
 
@@ -68,18 +71,32 @@ struct Char3DInfo
             return;
         }
 
-        _verts->push_back( pos );
-        setMinMax(pos);
+        if (!_currentPrimitiveSet)
+        {
+            _currentPrimitiveSet = new osg::DrawElementsUShort( osg::PrimitiveSet::POLYGON);
+            _currentPrimitiveSet->setName("boundary");
+        }
+
+        if (!(_currentPrimitiveSet->empty()) &&
+            (*_verts)[(*_currentPrimitiveSet)[0]] == pos)
+        {
+            OSG_NOTICE<<"Repeating first index "<<(*_currentPrimitiveSet)[0]<<", "<<(*_verts)[(*_currentPrimitiveSet)[0]]<<", pos="<<pos<<std::endl;
+            _currentPrimitiveSet->push_back( (*_currentPrimitiveSet)[0] );
+        }
+        else
+        {
+            _currentPrimitiveSet->push_back( _verts->size() );
+
+            _verts->push_back( pos );
+
+            setMinMax(pos);
+        }
     }
 
     void moveTo(const osg::Vec2& pos)
     {
-        if (_verts->size())
-        {
-            int len = _verts->size()-_idx;
-            _geometry->addPrimitiveSet( new osg::DrawArrays( osg::PrimitiveSet::POLYGON, _idx, len ) );
-        }
-        _idx = _verts->size();
+        completeCurrentPrimitiveSet();
+
         addVertex( osg::Vec3(pos.x(),pos.y(),0) );
 
     }
@@ -87,6 +104,7 @@ struct Char3DInfo
     {
         addVertex( osg::Vec3(pos.x(),pos.y(),0) );
     }
+
     void conicTo(const osg::Vec2& control, const osg::Vec2& pos)
     {
         osg::Vec3 p0 = _previous;
@@ -140,9 +158,9 @@ struct Char3DInfo
     }
 
     osg::ref_ptr<osg::Vec3Array>    _verts;
+    osg::ref_ptr<osg::DrawElementsUShort> _currentPrimitiveSet;
     osg::ref_ptr<osg::Geometry>     _geometry;
     osg::Vec3                       _previous;
-    int                             _idx;
     int                             _numSteps;
     double                          _maxY;
     double                          _maxX;
@@ -372,7 +390,7 @@ osgText::Glyph* FreeTypeFont::getGlyph(const osgText::FontResolution& fontRes, u
     unsigned int width = sourceWidth;
     unsigned int height = sourceHeight;
 
-    osg::ref_ptr<osgText::Glyph> glyph = new osgText::Glyph(charcode);
+    osg::ref_ptr<osgText::Glyph> glyph = new osgText::Glyph(_facade, charcode);
     
     unsigned int dataSize = width*height;
     unsigned char* data = new unsigned char[dataSize];
@@ -423,7 +441,11 @@ osgText::Glyph* FreeTypeFont::getGlyph(const osgText::FontResolution& fontRes, u
 
     FT_Glyph_Metrics* metrics = &(_face->glyph->metrics);
 
+#if 0
     float coord_scale = _freetype_scale/64.0f;
+#else
+    float coord_scale = 1.0f/64.0f;
+#endif
 
     glyph->setHorizontalBearing(osg::Vec2((float)metrics->horiBearingX * coord_scale,(float)(metrics->horiBearingY-metrics->height) * coord_scale)); // bottom left.
     glyph->setHorizontalAdvance((float)metrics->horiAdvance * coord_scale);
@@ -502,116 +524,13 @@ osgText::Glyph3D * FreeTypeFont::getGlyph3D(unsigned int charcode)
         rawPrimitives.push_back(dynamic_cast<osg::PrimitiveSet*>((*itr)->clone(osg::CopyOp::DEEP_COPY_ALL)));
     }
 
-    frontGeo->setVertexArray(char3d.get()->getVertexArray());
-    frontGeo->setPrimitiveSetList(char3d.get()->getPrimitiveSetList());
-
-    osg::ref_ptr<osg::Geometry> wallGeo(new osg::Geometry);
-    wallGeo->setVertexArray(frontGeo->getVertexArray());
-
-    osg::ref_ptr<osg::Geometry> backGeo(new osg::Geometry);
-    backGeo->setVertexArray(frontGeo->getVertexArray());
-
-
-
-    // ** for convenience.
-    osg::Vec3Array * vertices = char3d._verts.get();
-
-
-
-    // ** duplicate the vertex for the back face
-    // ** with a depth equal to the font depth
-    std::size_t len = vertices->size();
-    std::size_t dlen = len * 2;
-
-    vertices->reserve(dlen);
-
-    osg::Vec3Array::iterator begin = vertices->begin();
-    osg::Vec3Array::iterator it = vertices->begin();
-
-    for (std::size_t i = 0; i != len; ++i, ++it)
-        vertices->push_back(*it);
-//    std::copy(begin, begin + len, begin + len + 1); TOCHECK
-
-
-    // ** and decal new vertices
-    unsigned int depth = _facade->getFontDepth();
-    for (std::size_t i = len; i != dlen; ++i)
-    {
-        (*vertices)[i].z() -= depth;
-    }
-
-    osg::Vec3Array::iterator end;
-
-    // ** create wall and back face from the front polygon
-    // **  then accumulate them in the appropriate geometry wallGeo and backGeo
-    for (std::size_t i=0; i < frontGeo->getNumPrimitiveSets(); ++i)
-    {
-        // ** get the front polygon
-        osg::ref_ptr<osg::DrawArrays> daFront(dynamic_cast<osg::DrawArrays*>(frontGeo->getPrimitiveSet(i)));
-        unsigned int idx = daFront->getFirst();
-        unsigned int cnt = daFront->getCount();
-
-        // ** reverse vertices to draw the front face in the CCW
-        std::reverse(begin + idx, begin + idx + cnt);
-
-        // ** create the back polygon
-        osg::ref_ptr<osg::DrawArrays> daBack(new osg::DrawArrays(osg::PrimitiveSet::POLYGON, idx + len, cnt));
-        backGeo->addPrimitiveSet(daBack.get());
-
-
-        // ** create the wall triangle strip
-        osg::ref_ptr<osg::DrawElementsUInt> deWall(new osg::DrawElementsUInt(osg::PrimitiveSet::TRIANGLE_STRIP));
-        wallGeo->addPrimitiveSet(deWall.get());
-
-        // **  link triangle strip
-        deWall->push_back(idx + len);
-        for (unsigned int j = 1; j < cnt; ++j)
-        {
-            deWall->push_back(idx + cnt - j);
-            deWall->push_back(idx + len + j);
-        }
-        deWall->push_back(idx);
-        deWall->push_back(idx + len);
-        deWall->push_back(idx + cnt - 1);
-    }
-
-    // ** tesselate front and back face
-    {
-        osgUtil::Tessellator ts;
-        ts.setWindingType(osgUtil::Tessellator::TESS_WINDING_POSITIVE);
-        ts.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY);
-        ts.retessellatePolygons(*frontGeo);
-    }
-
-    {
-        osgUtil::Tessellator ts;
-        ts.setWindingType(osgUtil::Tessellator::TESS_WINDING_POSITIVE);
-        ts.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY);
-        ts.retessellatePolygons(*backGeo);
-    }
-
-    // ** generate normal
-    {
-        osgUtil::SmoothingVisitor sm;
-        osg::ref_ptr<osg::Geode> geode(new osg::Geode);
-        geode->addDrawable(wallGeo.get());
-        geode->accept(sm);
-    }
-
     // ** save vertices and PrimitiveSetList of each face in the Glyph3D PrimitiveSet face list
-    osg::ref_ptr<osgText::Glyph3D> glyph3D = new osgText::Glyph3D(charcode);
+    osg::ref_ptr<osgText::Glyph3D> glyph3D = new osgText::Glyph3D(_facade, charcode);
 
     // copy the raw primitive set list before we tessellate it.
     glyph3D->getRawFacePrimitiveSetList() = rawPrimitives;
     glyph3D->setRawVertexArray(rawVertices.get());
 
-    glyph3D->setVertexArray(dynamic_cast<osg::Vec3Array*>(frontGeo->getVertexArray()));
-    glyph3D->setNormalArray(dynamic_cast<osg::Vec3Array*>(wallGeo->getNormalArray()));
-
-    glyph3D->getFrontPrimitiveSetList() = frontGeo->getPrimitiveSetList();
-    glyph3D->getWallPrimitiveSetList() = wallGeo->getPrimitiveSetList();
-    glyph3D->getBackPrimitiveSetList() = backGeo->getPrimitiveSetList();
-
 
     FT_Glyph_Metrics* metrics = &(_face->glyph->metrics);
 
@@ -635,6 +554,9 @@ osgText::Glyph3D * FreeTypeFont::getGlyph3D(unsigned int charcode)
 
     glyph3D->setBoundingBox(bb);
 
+    glyph3D->computeText3DGeometryData();
+
+
     return glyph3D.release();
 }
 
diff --git a/src/osgPlugins/txf/TXFFont.cpp b/src/osgPlugins/txf/TXFFont.cpp
index ed95dc5d6..9726a80ea 100644
--- a/src/osgPlugins/txf/TXFFont.cpp
+++ b/src/osgPlugins/txf/TXFFont.cpp
@@ -227,7 +227,7 @@ TXFFont::loadFont(std::istream& stream)
             continue;
 
         // add the characters ...
-        osgText::Glyph* glyph = new osgText::Glyph(glyphs[i].ch);
+        osgText::Glyph* glyph = new osgText::Glyph(_facade, glyphs[i].ch);
 
         unsigned sourceWidth = glyphs[i].width;
         unsigned sourceHeight = glyphs[i].height;
@@ -269,7 +269,7 @@ TXFFont::loadFont(std::istream& stream)
     }
 
     // insert a trivial blank character
-    osgText::Glyph* glyph = new osgText::Glyph(' ');
+    osgText::Glyph* glyph = new osgText::Glyph(_facade, ' ');
 
     unsigned width = 1;
     unsigned height = 1;
diff --git a/src/osgQt/QFontImplementation.cpp b/src/osgQt/QFontImplementation.cpp
index 65cb632d5..563a358a7 100644
--- a/src/osgQt/QFontImplementation.cpp
+++ b/src/osgQt/QFontImplementation.cpp
@@ -83,7 +83,7 @@ QFontImplementation::getGlyph(const osgText::FontResolution& fontRes, unsigned i
     painter.end();
 
     // Transfer the rendered image to osg
-    osg::ref_ptr<osgText::Glyph> glyph = new osgText::Glyph(charcode);
+    osg::ref_ptr<osgText::Glyph> glyph = new osgText::Glyph(_facade, charcode);
 
     unsigned int dataSize = imageWidth*imageHeight;
     unsigned char* data = new unsigned char[dataSize];
diff --git a/src/osgText/CMakeLists.txt b/src/osgText/CMakeLists.txt
index f33ec6455..45d75b997 100644
--- a/src/osgText/CMakeLists.txt
+++ b/src/osgText/CMakeLists.txt
@@ -11,12 +11,14 @@ SET(LIB_PUBLIC_HEADERS
     ${HEADER_PATH}/Export
     ${HEADER_PATH}/Font
     ${HEADER_PATH}/Font3D
+    ${HEADER_PATH}/FadeText
+    ${HEADER_PATH}/Glyph
     ${HEADER_PATH}/KerningType
     ${HEADER_PATH}/String
     ${HEADER_PATH}/TextBase
     ${HEADER_PATH}/Text
+    ${HEADER_PATH}/TextNode
     ${HEADER_PATH}/Text3D
-    ${HEADER_PATH}/FadeText
     ${HEADER_PATH}/Version
 )
 
@@ -26,11 +28,15 @@ ADD_LIBRARY(${LIB_NAME}
     ${LIB_PUBLIC_HEADERS}
     DefaultFont.cpp
     DefaultFont.h
+    GlyphGeometry.h
+    GlyphGeometry.cpp
     Font.cpp
-    String.cpp
     FadeText.cpp
+    Glyph.cpp
+    String.cpp
     TextBase.cpp
     Text.cpp
+    TextNode.cpp
     Text3D.cpp
     Version.cpp
     ${OPENSCENEGRAPH_VERSIONINFO_RC}
diff --git a/src/osgText/DefaultFont.cpp b/src/osgText/DefaultFont.cpp
index 7783ef39d..aa9bf385d 100644
--- a/src/osgText/DefaultFont.cpp
+++ b/src/osgText/DefaultFont.cpp
@@ -194,7 +194,7 @@ void DefaultFont::constructGlyphs()
     // populate the glyph mp
     for(unsigned int i=32;i<127;i++)
     {
-        osg::ref_ptr<Glyph> glyph = new Glyph(i);
+        osg::ref_ptr<Glyph> glyph = new Glyph(this, i);
         
         unsigned int dataSize = sourceWidth*sourceHeight;
         unsigned char* data = new unsigned char[dataSize];
diff --git a/src/osgText/Font.cpp b/src/osgText/Font.cpp
index 5a8d98559..b5abd6499 100644
--- a/src/osgText/Font.cpp
+++ b/src/osgText/Font.cpp
@@ -493,463 +493,3 @@ void Font::addGlyph(const FontResolution& fontRes, unsigned int charcode, Glyph*
     glyphTexture->addGlyph(glyph,posX,posY);
     
 }
-
-
-GlyphTexture::GlyphTexture():
-    _margin(1),
-    _marginRatio(0.02f),
-    _usedY(0),
-    _partUsedX(0),
-    _partUsedY(0)
-{
-    setWrap(WRAP_S, CLAMP_TO_EDGE);
-    setWrap(WRAP_T, CLAMP_TO_EDGE);
-}
-
-GlyphTexture::~GlyphTexture() 
-{
-}
-
-// return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.
-int GlyphTexture::compare(const osg::StateAttribute& rhs) const
-{
-    if (this<&rhs) return -1;
-    else if (this>&rhs) return 1;
-    return 0;
-}
-
-
-bool GlyphTexture::getSpaceForGlyph(Glyph* glyph, int& posX, int& posY)
-{
-    int maxAxis = std::max(glyph->s(), glyph->t());
-    int margin = _margin + (int)((float)maxAxis * _marginRatio);
-    
-    int width = glyph->s()+2*margin;
-    int height = glyph->t()+2*margin;
-
-    // first check box (_partUsedX,_usedY) to (width,height)
-    if (width <= (getTextureWidth()-_partUsedX) &&
-        height <= (getTextureHeight()-_usedY))
-    {
-        // can fit in existing row.
-
-        // record the position in which the texture will be stored.
-        posX = _partUsedX+margin;
-        posY = _usedY+margin;        
-
-        // move used markers on.
-        _partUsedX += width;
-        if (_usedY+height>_partUsedY) _partUsedY = _usedY+height;
-        
-        return true;
-    }
-    
-    // start an new row.
-    if (width <= getTextureWidth() &&
-        height <= (getTextureHeight()-_partUsedY))
-    {
-        // can fit next row.
-        _partUsedX = 0;
-        _usedY = _partUsedY;
-
-        posX = _partUsedX+margin;
-        posY = _usedY+margin;        
-
-        // move used markers on.
-        _partUsedX += width;
-        if (_usedY+height>_partUsedY) _partUsedY = _usedY+height;
-        
-        return true;
-    }
-
-    // doesn't fit into glyph.
-    return false;
-}
-
-void GlyphTexture::addGlyph(Glyph* glyph, int posX, int posY)
-{
-    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
-
-    _glyphs.push_back(glyph);
-    for(unsigned int i=0;i<_glyphsToSubload.size();++i)
-    {
-        _glyphsToSubload[i].push_back(glyph);
-    }
-
-    // set up the details of where to place glyph's image in the texture.
-    glyph->setTexture(this);
-    glyph->setTexturePosition(posX,posY);
-
-    glyph->setMinTexCoord( osg::Vec2( static_cast<float>(posX)/static_cast<float>(getTextureWidth()),
-                                      static_cast<float>(posY)/static_cast<float>(getTextureHeight()) ) );
-    glyph->setMaxTexCoord( osg::Vec2( static_cast<float>(posX+glyph->s())/static_cast<float>(getTextureWidth()),
-                                      static_cast<float>(posY+glyph->t())/static_cast<float>(getTextureHeight()) ) );
-}
-
-void GlyphTexture::apply(osg::State& state) const
-{
-    // get the contextID (user defined ID of 0 upwards) for the 
-    // current OpenGL context.
-    const unsigned int contextID = state.getContextID();
-
-    if (contextID>=_glyphsToSubload.size())
-    {
-        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
-
-        // graphics context is beyond the number of glyphsToSubloads, so
-        // we must now copy the glyph list across, this is a potential
-        // threading issue though is multiple applies are happening the
-        // same time on this object - to avoid this condition number of
-        // graphics contexts should be set before create text.
-        for(unsigned int i=_glyphsToSubload.size();i<=contextID;++i)
-        {
-            GlyphPtrList& glyphPtrs = _glyphsToSubload[i];
-            for(GlyphRefList::const_iterator itr=_glyphs.begin();
-                itr!=_glyphs.end();
-                ++itr)
-            {
-                glyphPtrs.push_back(itr->get());
-            }
-        }
-    }
-
-
-    const Extensions* extensions = getExtensions(contextID,true);
-    bool generateMipMapSupported = extensions->isGenerateMipMapSupported();
-
-    // get the texture object for the current contextID.
-    TextureObject* textureObject = getTextureObject(contextID);
-    
-    bool newTextureObject = (textureObject == 0);
-
-    if (newTextureObject)
-    {
-        GLint maxTextureSize = 256;
-        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
-        if (maxTextureSize < getTextureWidth() || maxTextureSize < getTextureHeight())
-        {
-            OSG_WARN<<"Warning: osgText::Font texture size of ("<<getTextureWidth()<<", "<<getTextureHeight()<<") too large, unable to create font texture."<<std::endl;
-            OSG_WARN<<"         Maximum supported by hardward by native OpenGL implementation is ("<<maxTextureSize<<","<<maxTextureSize<<")."<<std::endl;
-            OSG_WARN<<"         Please set OSG_MAX_TEXTURE_SIZE lenvironment variable to "<<maxTextureSize<<" and re-run application."<<std::endl;
-            return;
-        }
-        
-        // being bound for the first time, need to allocate the texture
-
-        _textureObjectBuffer[contextID] = textureObject = osg::Texture::generateTextureObject(
-                this, contextID,GL_TEXTURE_2D,1,GL_ALPHA,getTextureWidth(), getTextureHeight(),1,0);
-
-        textureObject->bind();
-
-
-        applyTexParameters(GL_TEXTURE_2D,state);
-
-        
-        // need to look at generate mip map extension if mip mapping required.
-        switch(_min_filter)
-        {
-        case NEAREST_MIPMAP_NEAREST:
-        case NEAREST_MIPMAP_LINEAR:
-        case LINEAR_MIPMAP_NEAREST:
-        case LINEAR_MIPMAP_LINEAR:
-            if (generateMipMapSupported)
-            {
-                glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,GL_TRUE);
-            }
-            else glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, LINEAR);
-            break;
-        default:
-            // not mip mapping so no problems.
-            break;
-        }
-        
-        unsigned int imageDataSize = getTextureHeight()*getTextureWidth();
-        unsigned char* imageData = new unsigned char[imageDataSize];
-        for(unsigned int i=0; i<imageDataSize; ++i)
-        {
-            imageData[i] = 0;
-        }
-        
-
-//        OSG_NOTICE<<"Texture width = "<<getTextureWidth()<<std::endl;
-//        OSG_NOTICE<<"Texture height = "<<getTextureHeight()<<std::endl;
-               
-        // allocate the texture memory.
-        glTexImage2D( GL_TEXTURE_2D, 0, GL_ALPHA,
-                getTextureWidth(), getTextureHeight(), 0,
-                GL_ALPHA,
-                GL_UNSIGNED_BYTE,
-                imageData );
-                
-        delete [] imageData;
-    
-    }
-    else
-    {
-        // reuse texture by binding.
-        textureObject->bind();
-        
-        if (getTextureParameterDirty(contextID))
-        {
-            applyTexParameters(GL_TEXTURE_2D,state);
-        }
-
-
-    }
-    
-    static const GLubyte* s_renderer = 0;
-    static bool s_subloadAllGlyphsTogether = false;
-    if (!s_renderer)
-    {
-        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
-
-        s_renderer = glGetString(GL_RENDERER);
-        OSG_INFO<<"glGetString(GL_RENDERER)=="<<s_renderer<<std::endl;
-        if (s_renderer && strstr((const char*)s_renderer,"IMPACT")!=0)
-        {
-            // we're running on an Octane, so need to work around its
-            // subloading bugs by loading all at once.
-            s_subloadAllGlyphsTogether = true;
-        }
-        
-        if (s_renderer && 
-            ((strstr((const char*)s_renderer,"Radeon")!=0) || 
-            (strstr((const char*)s_renderer,"RADEON")!=0) ||
-            (strstr((const char*)s_renderer,"ALL-IN-WONDER")!=0)))
-        {
-            // we're running on an ATI, so need to work around its
-            // subloading bugs by loading all at once.
-            s_subloadAllGlyphsTogether = true;
-        }
-
-        if (s_renderer && strstr((const char*)s_renderer,"Sun")!=0)
-        {
-            // we're running on an solaris x server, so need to work around its
-            // subloading bugs by loading all at once.
-            s_subloadAllGlyphsTogether = true;
-        }
-
-        const char* str = getenv("OSG_TEXT_INCREMENTAL_SUBLOADING");
-        if (str)
-        {
-            s_subloadAllGlyphsTogether = strcmp(str,"OFF")==0 || strcmp(str,"Off")==0 || strcmp(str,"off")==0;
-        }
-    }
-
-
-    // now subload the glyphs that are outstanding for this graphics context.
-    GlyphPtrList& glyphsWereSubloading = _glyphsToSubload[contextID];
-
-    if (!glyphsWereSubloading.empty() || newTextureObject)
-    {
-        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
-
-        if (!s_subloadAllGlyphsTogether)
-        {
-            if (newTextureObject)
-            {
-                for(GlyphRefList::const_iterator itr=_glyphs.begin();
-                    itr!=_glyphs.end();
-                    ++itr)
-                {
-                    (*itr)->subload();
-                }
-            }
-            else // just subload the new entries.
-            {            
-                // default way of subloading as required.
-                //std::cout<<"subloading"<<std::endl;
-                for(GlyphPtrList::iterator itr=glyphsWereSubloading.begin();
-                    itr!=glyphsWereSubloading.end();
-                    ++itr)
-                {
-                    (*itr)->subload();
-                }
-            }
-            
-            // clear the list since we have now subloaded them.
-            glyphsWereSubloading.clear();
-            
-        }
-        else
-        {
-            OSG_INFO<<"osgText::Font loading all glyphs as a single subload."<<std::endl;
-
-            // Octane has bugs in OGL driver which mean that subloads smaller
-            // than 32x32 produce errors, and also cannot handle general alignment,
-            // so to get round this copy all glyphs into a temporary image and
-            // then subload the whole lot in one go.
-
-            int tsize = getTextureHeight() * getTextureWidth();
-            unsigned char *local_data = new unsigned char[tsize];
-            memset( local_data, 0L, tsize);
-
-            for(GlyphRefList::const_iterator itr=_glyphs.begin();
-                itr!=_glyphs.end();
-                ++itr)
-            {
-                //(*itr)->subload();
-
-                // Rather than subloading to graphics, we'll write the values
-                // of the glyphs into some intermediate data and subload the
-                // whole thing at the end
-                for( int t = 0; t < (*itr)->t(); t++ )
-                {
-                    for( int s = 0; s < (*itr)->s(); s++ )
-                    {
-                        int sindex = (t*(*itr)->s()+s);
-                        int dindex =  
-                            ((((*itr)->getTexturePositionY()+t) * getTextureWidth()) +
-                            ((*itr)->getTexturePositionX()+s));
-
-                        const unsigned char *sptr = &(*itr)->data()[sindex];
-                        unsigned char *dptr       = &local_data[dindex];
-
-                        (*dptr)   = (*sptr);
-                    }
-                }
-            }
-
-            // clear the list since we have now subloaded them.
-            glyphsWereSubloading.clear();
-
-            // Subload the image once
-            glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 
-                    getTextureWidth(),
-                    getTextureHeight(),
-                    GL_ALPHA, GL_UNSIGNED_BYTE, local_data );
-
-            delete [] local_data;
-
-        }
-    }
-    else
-    {
-//        OSG_INFO << "no need to subload "<<std::endl;
-    }
-
-
-
-//     if (generateMipMapTurnedOn)
-//     {
-//         glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,GL_FALSE);
-//     }
-
-
-}
-
-void GlyphTexture::setThreadSafeRefUnref(bool threadSafe)
-{
-    osg::Texture2D::setThreadSafeRefUnref(threadSafe);
-}
-
-void GlyphTexture::resizeGLObjectBuffers(unsigned int maxSize)
-{
-    osg::Texture2D::resizeGLObjectBuffers(maxSize);
-    _glyphsToSubload.resize(maxSize);
-}
-
-
-// all the methods in Font::Glyph have been made non inline because VisualStudio6.0 is STUPID, STUPID, STUPID PILE OF JUNK.
-Glyph::Glyph(unsigned int glyphCode):
-    _font(0),
-    _glyphCode(glyphCode),
-    _horizontalBearing(0.0f,0.f),
-    _horizontalAdvance(0.f),
-    _verticalBearing(0.0f,0.f),
-    _verticalAdvance(0.f),
-    _texture(0),
-    _texturePosX(0),
-    _texturePosY(0),
-    _minTexCoord(0.0f,0.0f),
-    _maxTexCoord(0.0f,0.0f)
-{
-    setThreadSafeRefUnref(true);
-}
-
-Glyph::~Glyph()
-{
-}
-
-void Glyph::setHorizontalBearing(const osg::Vec2& bearing) {  _horizontalBearing=bearing; }
-const osg::Vec2& Glyph::getHorizontalBearing() const { return _horizontalBearing; }
-
-void Glyph::setHorizontalAdvance(float advance) { _horizontalAdvance=advance; }
-float Glyph::getHorizontalAdvance() const { return _horizontalAdvance; }
-
-void Glyph::setVerticalBearing(const osg::Vec2& bearing) {  _verticalBearing=bearing; }
-const osg::Vec2& Glyph::getVerticalBearing() const { return _verticalBearing; }
-
-void Glyph::setVerticalAdvance(float advance) {  _verticalAdvance=advance; }
-float Glyph::getVerticalAdvance() const { return _verticalAdvance; }
-
-void Glyph::setTexture(GlyphTexture* texture) { _texture = texture; }
-GlyphTexture* Glyph::getTexture() { return _texture; }
-const GlyphTexture* Glyph::getTexture() const { return _texture; }
-
-void Glyph::setTexturePosition(int posX,int posY) { _texturePosX = posX; _texturePosY = posY; }
-int Glyph::getTexturePositionX() const { return _texturePosX; }
-int Glyph::getTexturePositionY() const { return _texturePosY; }
-
-void Glyph::setMinTexCoord(const osg::Vec2& coord) { _minTexCoord=coord; }
-const osg::Vec2& Glyph::getMinTexCoord() const { return _minTexCoord; }
-
-void Glyph::setMaxTexCoord(const osg::Vec2& coord) { _maxTexCoord=coord; }
-const osg::Vec2& Glyph::getMaxTexCoord() const { return _maxTexCoord; }
-
-void Glyph::subload() const
-{
-    GLenum errorNo = glGetError();
-    if (errorNo!=GL_NO_ERROR)
-    {
-#ifdef OSG_GLU_AVAILABLE
-        const GLubyte* msg = gluErrorString(errorNo);
-        if (msg) { OSG_WARN<<"before Glyph::subload(): detected OpenGL error: "<<msg<<std::endl; }
-        else  { OSG_WARN<<"before Glyph::subload(): detected OpenGL error number: "<<errorNo<<std::endl; }
-#else
-        OSG_WARN<<"before Glyph::subload(): detected OpenGL error number: "<<errorNo<<std::endl;
-#endif
-    }
-
-    if(s() <= 0 || t() <= 0)
-    {
-        OSG_INFO<<"Glyph::subload(): texture sub-image width and/or height of 0, ignoring operation."<<std::endl;
-        return;
-    }
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT,getPacking());
-
-    glTexSubImage2D(GL_TEXTURE_2D,0,
-                    _texturePosX,_texturePosY,
-                    s(),t(),
-                    (GLenum)getPixelFormat(),
-                    (GLenum)getDataType(),
-                    data());
-                    
-    errorNo = glGetError();
-    if (errorNo!=GL_NO_ERROR)
-    {
-
-
-#ifdef OSG_GLU_AVAILABLE
-        const GLubyte* msg = gluErrorString(errorNo);
-        if (msg) { OSG_WARN<<"after Glyph::subload() : detected OpenGL error: "<<msg<<std::endl; }
-        else { OSG_WARN<<"after Glyph::subload() : detected OpenGL error number: "<<errorNo<<std::endl; }
-#else
-        OSG_WARN<<"after Glyph::subload() : detected OpenGL error number: "<<errorNo<<std::endl;
-#endif
-
-        OSG_WARN<< "\tglTexSubImage2D(0x"<<hex<<GL_TEXTURE_2D<<dec<<" ,"<<0<<"\t"<<std::endl<<
-                                 "\t                "<<_texturePosX<<" ,"<<_texturePosY<<std::endl<<
-                                 "\t                "<<s()<<" ,"<<t()<<std::endl<<hex<<
-                                 "\t                0x"<<(GLenum)getPixelFormat()<<std::endl<<
-                                 "\t                0x"<<(GLenum)getDataType()<<std::endl<<
-                                 "\t                0x"<<(unsigned long)data()<<");"<<dec<<std::endl;
-    }                    
-}
-
-void Glyph3D::setThreadSafeRefUnref(bool threadSafe)
-{
-    if (_vertexArray.valid()) _vertexArray->setThreadSafeRefUnref(threadSafe);
-    if (_normalArray.valid()) _normalArray->setThreadSafeRefUnref(threadSafe);
-}
diff --git a/src/osgText/GlyphGeometry.cpp b/src/osgText/GlyphGeometry.cpp
new file mode 100644
index 000000000..12e4556f7
--- /dev/null
+++ b/src/osgText/GlyphGeometry.cpp
@@ -0,0 +1,1061 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library 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
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include "GlyphGeometry.h"
+
+#include <osg/io_utils>
+#include <osg/TriangleIndexFunctor>
+#include <osg/LineWidth>
+#include <osgUtil/Tessellator>
+#include <osg/CullFace>
+
+#include <limits.h>
+
+namespace osgText
+{
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// Boundary
+//
+class Boundary
+{
+public:
+
+    typedef std::pair<unsigned int, unsigned int> Segment;
+    typedef std::vector<Segment>  Segments;
+    osg::ref_ptr<osg::Vec3Array> _vertices;
+    osg::ref_ptr<osg::DrawElementsUShort> _elements;
+    Segments _segments;
+
+    Boundary(osg::Vec3Array* vertices, osg::PrimitiveSet* primitiveSet)
+    {
+        osg::DrawArrays* drawArrays = dynamic_cast<osg::DrawArrays*>(primitiveSet);
+        if (drawArrays)
+        {
+            set(vertices, drawArrays->getFirst(), drawArrays->getCount());
+        }
+        else
+        {
+            osg::DrawElementsUShort* elements = dynamic_cast<osg::DrawElementsUShort*>(primitiveSet);
+            if (elements) set(vertices, elements);
+        }
+    }
+
+    void set(osg::Vec3Array* vertices, unsigned int start, unsigned int count)
+    {
+        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(osg::PrimitiveSet::POLYGON);
+        for(unsigned int i=start; i<start+count; ++i)
+        {
+            elements->push_back(i);
+        }
+
+        set(vertices, elements);
+    }
+
+    void set(osg::Vec3Array* vertices, osg::DrawElementsUShort* elements)
+    {
+        _vertices = vertices;
+        _elements = elements;
+
+        _segments.clear();
+
+        if (elements->empty()) return;
+
+        _segments.reserve(elements->size()-1);
+        for(unsigned int i=0; i<elements->size()-1; ++i)
+        {
+            _segments.push_back(Segment((*elements)[i],(*elements)[i+1]));
+        }
+    }
+
+    osg::Vec3 computeRayIntersectionPoint(const osg::Vec3& a, const osg::Vec3& an, const osg::Vec3& c, const osg::Vec3& cn)
+    {
+        float denominator = ( cn.x() * an.y() - cn.y() * an.x());
+        if (denominator==0.0f)
+        {
+            //OSG_NOTICE<<"computeRayIntersectionPoint()<<denominator==0.0"<<std::endl;
+            // line segments must be parallel.
+            return (a+c)*0.5f;
+        }
+
+        float t = ((a.x()-c.x())*an.y() - (a.y()-c.y())*an.x()) / denominator;
+        return c + cn*t;
+    }
+
+    osg::Vec3 computeIntersectionPoint(const osg::Vec3& a, const osg::Vec3& b, const osg::Vec3& c, const osg::Vec3& d)
+    {
+        return computeRayIntersectionPoint(a, b-a, c, d-c);
+    }
+
+    osg::Vec3 computeBisectorNormal(const osg::Vec3& a, const osg::Vec3& b, const osg::Vec3& c, const osg::Vec3& d)
+    {
+        osg::Vec2 ab(a.x()-b.x(), a.y()-b.y());
+        osg::Vec2 dc(d.x()-c.x(), d.y()-c.y());
+        /*float length_ab =*/ ab.normalize();
+        /*float length_dc =*/ dc.normalize();
+
+        float e = dc.y() - ab.y();
+        float f = ab.x() - dc.x();
+        float denominator = sqrtf(e*e + f*f);
+        float nx = e / denominator;
+        float ny = f / denominator;
+        if (( ab.x()*ny - ab.y()*nx) > 0.0f)
+        {
+            // OSG_NOTICE<<"   computeBisectorNormal(a=["<<a<<"], b=["<<b<<"], c=["<<c<<"], d=["<<d<<"]), nx="<<nx<<", ny="<<ny<<", denominator="<<denominator<<" no need to swap"<<std::endl;
+            return osg::Vec3(nx,ny,0.0f);
+        }
+        else
+        {
+            OSG_NOTICE<<"   computeBisectorNormal(a=["<<a<<"], b=["<<b<<"], c=["<<c<<"], d=["<<d<<"]), nx="<<nx<<", ny="<<ny<<", denominator="<<denominator<<" need to swap!!!"<<std::endl;
+            return osg::Vec3(-nx,-ny,0.0f);
+        }
+    }
+
+    float computeBisectorIntersectorThickness(const osg::Vec3& a, const osg::Vec3& b, const osg::Vec3& c, const osg::Vec3& d, const osg::Vec3& e, const osg::Vec3& f)
+    {
+        osg::Vec3 intersection_abcd = computeIntersectionPoint(a,b,c,d);
+        osg::Vec3 bisector_abcd = computeBisectorNormal(a,b,c,d);
+        osg::Vec3 intersection_cdef = computeIntersectionPoint(c,d,e,f);
+        osg::Vec3 bisector_cdef = computeBisectorNormal(c,d,e,f);
+        if (bisector_abcd==bisector_cdef)
+        {
+            //OSG_NOTICE<<"computeBisectorIntersector(["<<a<<"], ["<<b<<"], ["<<c<<"], ["<<d<<"], ["<<e<<"], ["<<f<<"[)"<<std::endl;
+            //OSG_NOTICE<<"   bisectors parallel, thickness = "<<FLT_MAX<<std::endl;
+            return FLT_MAX;
+        }
+
+        osg::Vec3 bisector_intersection = computeRayIntersectionPoint(intersection_abcd,bisector_abcd, intersection_cdef, bisector_cdef);
+        osg::Vec3 normal(d.y()-c.y(), c.x()-d.x(), 0.0);
+        float cd_length = normal.normalize();
+        if (cd_length==0)
+        {
+            //OSG_NOTICE<<"computeBisectorIntersector(["<<a<<"], ["<<b<<"], ["<<c<<"], ["<<d<<"], ["<<e<<"], ["<<f<<"[)"<<std::endl;
+            //OSG_NOTICE<<"   segment length==0, thickness = "<<FLT_MAX<<std::endl;
+            return FLT_MAX;
+        }
+
+        float thickness = (bisector_intersection - c) * normal;
+    #if 0
+        OSG_NOTICE<<"computeBisectorIntersector(["<<a<<"], ["<<b<<"], ["<<c<<"], ["<<d<<"], ["<<e<<"], ["<<f<<"[)"<<std::endl;
+        OSG_NOTICE<<"   bisector_abcd = "<<bisector_abcd<<", bisector_cdef="<<bisector_cdef<<std::endl;
+        OSG_NOTICE<<"   bisector_intersection = "<<bisector_intersection<<", thickness = "<<thickness<<std::endl;
+    #endif
+        return thickness;
+    }
+
+
+    float computeThickness(unsigned int i)
+    {
+        Segment& seg_before = _segments[ (i+_segments.size()-1) % _segments.size() ];
+        Segment& seg_target = _segments[ (i) % _segments.size() ];
+        Segment& seg_after =  _segments[ (i+1) % _segments.size() ];
+        return computeBisectorIntersectorThickness(
+            (*_vertices)[seg_before.first], (*_vertices)[seg_before.second],
+            (*_vertices)[seg_target.first], (*_vertices)[seg_target.second],
+            (*_vertices)[seg_after.first], (*_vertices)[seg_after.second]);
+    }
+
+    void computeAllThickness()
+    {
+        for(unsigned int i=0; i<_segments.size(); ++i)
+        {
+            computeThickness(i);
+        }
+    }
+
+
+    bool findMinThickness(unsigned int& minThickness_i, float& minThickness)
+    {
+        minThickness_i = _segments.size();
+        for(unsigned int i=0; i<_segments.size(); ++i)
+        {
+            float thickness = computeThickness(i);
+            if (thickness>0.0 && thickness <  minThickness)
+            {
+                minThickness = thickness;
+                minThickness_i = i;
+            }
+        }
+
+        return minThickness_i != _segments.size();
+    }
+
+    void removeAllSegmentsBelowThickness(float targetThickness)
+    {
+        // OSG_NOTICE<<"removeAllSegmentsBelowThickness("<<targetThickness<<")"<<std::endl;
+        for(;;)
+        {
+            unsigned int minThickness_i = _segments.size();
+            float minThickness = targetThickness;
+            if (!findMinThickness(minThickness_i,minThickness)) break;
+
+            // OSG_NOTICE<<"  removing segment _segments["<<minThickness_i<<"] ("<<_segments[minThickness_i].first<<", "<<_segments[minThickness_i].second<<" with thickness="<<minThickness<<" "<<std::endl;
+            _segments.erase(_segments.begin()+minThickness_i);
+        }
+    }
+
+    bool findMaxThickness(unsigned int& maxThickness_i, float& maxThickness)
+    {
+        maxThickness_i = _segments.size();
+        for(unsigned int i=0; i<_segments.size(); ++i)
+        {
+            float thickness = computeThickness(i);
+            if (thickness<0.0 && thickness >  maxThickness)
+            {
+                maxThickness = thickness;
+                maxThickness_i = i;
+            }
+        }
+
+        return maxThickness_i != _segments.size();
+    }
+
+
+    void removeAllSegmentsAboveThickness(float targetThickness)
+    {
+        // OSG_NOTICE<<"removeAllSegmentsBelowThickness("<<targetThickness<<")"<<std::endl;
+        for(;;)
+        {
+            unsigned int maxThickness_i = _segments.size();
+            float maxThickness = targetThickness;
+            if (!findMaxThickness(maxThickness_i,maxThickness)) break;
+
+            // OSG_NOTICE<<"  removing segment _segments["<<minThickness_i<<"] ("<<_segments[minThickness_i].first<<", "<<_segments[minThickness_i].second<<" with thickness="<<minThickness<<" "<<std::endl;
+            _segments.erase(_segments.begin()+maxThickness_i);
+        }
+    }
+
+    osg::Vec3 computeBisectorPoint(unsigned int i, float targetThickness)
+    {
+        Segment& seg_before = _segments[ (i+_segments.size()-1) % _segments.size() ];
+        Segment& seg_target = _segments[ (i) % _segments.size() ];
+        osg::Vec3& a = (*_vertices)[seg_before.first];
+        osg::Vec3& b = (*_vertices)[seg_before.second];
+        osg::Vec3& c = (*_vertices)[seg_target.first];
+        osg::Vec3& d = (*_vertices)[seg_target.second];
+        osg::Vec3 intersection_abcd = computeIntersectionPoint(a,b,c,d);
+        osg::Vec3 bisector_abcd = computeBisectorNormal(a,b,c,d);
+        osg::Vec3 ab_sidevector(b.y()-a.y(), a.x()-b.x(), 0.0);
+        ab_sidevector.normalize();
+        float scale_factor = 1.0/ (bisector_abcd*ab_sidevector);
+        osg::Vec3 new_vertex = intersection_abcd + bisector_abcd*(scale_factor*targetThickness);
+
+        // OSG_NOTICE<<"bisector_abcd = "<<bisector_abcd<<", ab_sidevector="<<ab_sidevector<<", b-a="<<b-a<<", scale_factor="<<scale_factor<<std::endl;
+        return new_vertex;
+    }
+
+    void addBoundaryToGeometry(osg::Geometry* geometry, float targetThickness, bool requireFace)
+    {
+        if (_segments.empty()) return;
+
+        if (geometry->getVertexArray()==0) geometry->setVertexArray(new osg::Vec3Array);
+        osg::Vec3Array* new_vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
+
+        // allocate the primitive set to store the face geometry
+        osg::ref_ptr<osg::DrawElementsUShort> face = new osg::DrawElementsUShort(GL_POLYGON);
+        face->setName("face");
+
+        // reserve enough space in the vertex array to accomodate the vertices associated with the segments
+        new_vertices->reserve(new_vertices->size() + _segments.size()+1 + _elements->size());
+
+        // create vertices
+        unsigned int previous_second = _segments[0].second;
+        osg::Vec3 newPoint = computeBisectorPoint(0, targetThickness);
+        unsigned int first = new_vertices->size();
+        new_vertices->push_back(newPoint);
+
+        unsigned int start = (*_elements)[0];
+        unsigned int count = _elements->size();
+
+        if (_segments[0].first != start)
+        {
+            //OSG_NOTICE<<"We have pruned from the start"<<std::endl;
+            for(unsigned int j=start; j<=_segments[0].first;++j)
+            {
+                face->push_back(first);
+            }
+        }
+        else
+        {
+            face->push_back(first);
+        }
+
+
+        for(unsigned int i=1; i<_segments.size(); ++i)
+        {
+            newPoint = computeBisectorPoint(i, targetThickness);
+            unsigned int vi = new_vertices->size();
+            new_vertices->push_back(newPoint);
+
+            if (previous_second != _segments[i].first)
+            {
+                //OSG_NOTICE<<"Gap in boundary"<<previous_second<<" to "<<_segments[i].first<<std::endl;
+                for(unsigned int j=previous_second; j<=_segments[i].first;++j)
+                {
+                    face->push_back(vi);
+                }
+            }
+            else
+            {
+                face->push_back(vi);
+            }
+
+            previous_second = _segments[i].second;
+        }
+
+        // fill the end of the polygon with repititions of the first index in the polygon to ensure
+        // that the orignal and new boundary polygons have the same number and pairing of indices.
+        // This ensures that the bevel can be created coherently.
+        while(face->size() < count)
+        {
+            face->push_back(first);
+        }
+
+
+        if (requireFace)
+        {
+            // add face primitive set for polygon
+            geometry->addPrimitiveSet(face.get());
+        }
+
+        
+        osg::DrawElementsUShort* bevel = new osg::DrawElementsUShort(GL_QUAD_STRIP);
+        bevel->setName("bevel");
+        bevel->reserve(count*2);
+        for(unsigned int i=0; i<count; ++i)
+        {
+            unsigned int vi = new_vertices->size();
+            new_vertices->push_back((*_vertices)[(*_elements)[i]]);
+            bevel->push_back(vi);
+            bevel->push_back((*face)[i]);
+        }
+        geometry->addPrimitiveSet(bevel);
+    }
+
+    void newAddBoundaryToGeometry(osg::Geometry* geometry, float targetThickness, const std::string& faceName, const std::string& bevelName)
+    {
+        if (_segments.empty()) return;
+
+        unsigned int start = (*_elements)[0];
+        unsigned int count = _elements->size();
+
+        if (geometry->getVertexArray()==0) geometry->setVertexArray(new osg::Vec3Array(*_vertices));
+        osg::Vec3Array* new_vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
+
+        // allocate the primitive set to store the face geometry
+        osg::ref_ptr<osg::DrawElementsUShort> face = new osg::DrawElementsUShort(GL_POLYGON);
+        face->setName(faceName);
+
+        // reserve enough space in the vertex array to accomodate the vertices associated with the segments
+        new_vertices->reserve(new_vertices->size() + _segments.size()+1 + count);
+
+        // create vertices
+        unsigned int previous_second = _segments[0].second;
+        osg::Vec3 newPoint = computeBisectorPoint(0, targetThickness);
+        unsigned int first = new_vertices->size();
+        new_vertices->push_back(newPoint);
+
+        if (_segments[0].first != start)
+        {
+            //OSG_NOTICE<<"We have pruned from the start"<<std::endl;
+            for(unsigned int j=start; j<=_segments[0].first;++j)
+            {
+                face->push_back(first);
+            }
+        }
+        else
+        {
+            face->push_back(first);
+        }
+
+
+        for(unsigned int i=1; i<_segments.size(); ++i)
+        {
+            newPoint = computeBisectorPoint(i, targetThickness);
+            unsigned int vi = new_vertices->size();
+            new_vertices->push_back(newPoint);
+
+            if (previous_second != _segments[i].first)
+            {
+                //OSG_NOTICE<<"Gap in boundary"<<previous_second<<" to "<<_segments[i].first<<std::endl;
+                for(unsigned int j=previous_second; j<=_segments[i].first;++j)
+                {
+                    face->push_back(vi);
+                }
+            }
+            else
+            {
+                face->push_back(vi);
+            }
+
+            previous_second = _segments[i].second;
+        }
+
+        // fill the end of the polygon with repititions of the first index in the polygon to ensure
+        // that the orignal and new boundary polygons have the same number and pairing of indices.
+        // This ensures that the bevel can be created coherently.
+        while(face->size() < count)
+        {
+            face->push_back(first);
+        }
+
+        if (!faceName.empty())
+        {
+            // add face primitive set for polygon
+            geometry->addPrimitiveSet(face.get());
+        }
+
+        osg::DrawElementsUShort* bevel = new osg::DrawElementsUShort(GL_QUAD_STRIP);
+        bevel->setName(bevelName);
+        bevel->reserve(count*2);
+        for(unsigned int i=0; i<count; ++i)
+        {
+            bevel->push_back((*_elements)[i]);
+            bevel->push_back((*face)[i]);
+        }
+        geometry->addPrimitiveSet(bevel);
+    }
+};
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// computeGlyphGeometry
+//
+struct CollectTriangleIndicesFunctor
+{
+    CollectTriangleIndicesFunctor() {}
+
+    typedef std::vector<unsigned int> Indices;
+    Indices _indices;
+
+    void operator() (unsigned int p1, unsigned int p2, unsigned int p3)
+    {
+        if (p1==p2 || p2==p3 || p1==p3)
+        {
+            return;
+        }
+
+        _indices.push_back(p1);
+        _indices.push_back(p3);
+        _indices.push_back(p2);
+
+    }
+};
+
+
+osg::Geometry* computeGlyphGeometry(osgText::Glyph3D* glyph, float bevelThickness, float shellThickness)
+{
+    osg::Vec3Array* orig_vertices = glyph->getRawVertexArray();
+    osg::Geometry::PrimitiveSetList& orig_primitives = glyph->getRawFacePrimitiveSetList();
+
+    osg::ref_ptr<osg::Geometry> new_geometry = new osg::Geometry;
+
+    for(osg::Geometry::PrimitiveSetList::iterator itr = orig_primitives.begin();
+        itr != orig_primitives.end();
+        ++itr)
+    {
+        if ((*itr)->getMode()==GL_POLYGON)
+        {
+            Boundary boundaryInner(orig_vertices, itr->get());
+            boundaryInner.removeAllSegmentsBelowThickness(bevelThickness);
+            boundaryInner.newAddBoundaryToGeometry(new_geometry, bevelThickness, "face", "bevel");
+
+            Boundary boundaryOuter(orig_vertices, itr->get());
+            boundaryOuter.removeAllSegmentsAboveThickness(-shellThickness);
+            boundaryOuter.newAddBoundaryToGeometry(new_geometry, -shellThickness, "", "shell");
+        }
+        
+    }
+
+    osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(new_geometry->getVertexArray());
+
+    // need to tessellate the inner boundary
+    {
+        osg::ref_ptr<osg::Geometry> face_geometry = new osg::Geometry;
+        face_geometry->setVertexArray(vertices);
+
+        osg::CopyOp copyop(osg::CopyOp::DEEP_COPY_ALL);
+
+        osg::Geometry::PrimitiveSetList primitiveSets;
+
+        for(osg::Geometry::PrimitiveSetList::iterator itr = new_geometry->getPrimitiveSetList().begin();
+            itr != new_geometry->getPrimitiveSetList().end();
+            ++itr)
+        {
+            osg::PrimitiveSet* prim = itr->get();
+            if (prim->getName()=="face")  face_geometry->addPrimitiveSet(copyop(*itr));
+            else primitiveSets.push_back(prim);
+        }
+
+        osgUtil::Tessellator ts;
+        ts.setWindingType(osgUtil::Tessellator::TESS_WINDING_POSITIVE);
+        ts.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY);
+        ts.retessellatePolygons(*face_geometry);
+
+        osg::TriangleIndexFunctor<CollectTriangleIndicesFunctor> ctif;
+        face_geometry->accept(ctif);
+        CollectTriangleIndicesFunctor::Indices& indices = ctif._indices;
+
+        // remove the previous primitive sets
+        new_geometry->getPrimitiveSetList().clear();
+
+        // create a front face using triangle indices
+        osg::DrawElementsUShort* front_face = new osg::DrawElementsUShort(GL_TRIANGLES);
+        front_face->setName("face");
+        new_geometry->addPrimitiveSet(front_face);
+        for(unsigned int i=0; i<indices.size();++i)
+        {
+            front_face->push_back(indices[i]);
+        }
+
+        for(osg::Geometry::PrimitiveSetList::iterator itr = primitiveSets.begin();
+            itr != primitiveSets.end();
+            ++itr)
+        {
+            osg::PrimitiveSet* prim = itr->get();
+            if (prim->getName()!="face")  new_geometry->addPrimitiveSet(prim);
+        }
+    }
+
+    return new_geometry.release();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// computeTextGeometry
+//
+osg::Geometry* computeTextGeometry(osgText::Glyph3D* glyph, float width)
+{
+    osg::Vec3Array* orig_vertices = glyph->getRawVertexArray();
+    osg::Geometry::PrimitiveSetList& orig_primitives = glyph->getRawFacePrimitiveSetList();
+
+    osg::ref_ptr<osg::Geometry> text_geometry = new osg::Geometry;
+    osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array((*orig_vertices));
+
+    text_geometry->setVertexArray(vertices.get());
+    text_geometry->setPrimitiveSetList(orig_primitives);
+
+    osgUtil::Tessellator ts;
+    ts.setWindingType(osgUtil::Tessellator::TESS_WINDING_POSITIVE);
+    ts.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY);
+    ts.retessellatePolygons(*text_geometry);
+
+    osg::TriangleIndexFunctor<CollectTriangleIndicesFunctor> ctif;
+    text_geometry->accept(ctif);
+    CollectTriangleIndicesFunctor::Indices& indices = ctif._indices;
+
+    // remove the previous primitive sets
+    text_geometry->getPrimitiveSetList().clear();
+
+    if (indices.empty()) return 0;
+
+
+    // create a front face using triangle indices
+    osg::DrawElementsUShort* frontFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    frontFace->setName("front");
+    text_geometry->addPrimitiveSet(frontFace);
+    for(unsigned int i=0; i<indices.size();++i)
+    {
+        frontFace->push_back(indices[i]);
+    }
+
+    typedef std::vector<unsigned int> Indices;
+    const unsigned int NULL_VALUE = UINT_MAX;
+    Indices back_indices;
+    back_indices.resize(vertices->size(), NULL_VALUE);
+    osg::Vec3 forward(0,0,-width);
+
+    // build up the vertices primitives for the back face, and record the indices
+    // for later use, and to ensure sharing of vertices in the face primitive set
+    // the order of the triangle indices are flipped to make sure that the triangles are back face
+    osg::DrawElementsUShort* backFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    backFace->setName("back");
+    text_geometry->addPrimitiveSet(backFace);
+    for(unsigned int i=0; i<indices.size()-2;)
+    {
+        unsigned int p1 = indices[i++];
+        unsigned int p2 = indices[i++];
+        unsigned int p3 = indices[i++];
+        if (back_indices[p1]==NULL_VALUE)
+        {
+            back_indices[p1] = vertices->size();
+            vertices->push_back((*vertices)[p1]+forward);
+        }
+
+        if (back_indices[p2]==NULL_VALUE)
+        {
+            back_indices[p2] = vertices->size();
+            vertices->push_back((*vertices)[p2]+forward);
+        }
+
+        if (back_indices[p3]==NULL_VALUE)
+        {
+            back_indices[p3] = vertices->size();
+            vertices->push_back((*vertices)[p3]+forward);
+        }
+
+        backFace->push_back(back_indices[p1]);
+        backFace->push_back(back_indices[p3]);
+        backFace->push_back(back_indices[p2]);
+    }
+
+    unsigned int orig_size = orig_vertices->size();
+    Indices frontedge_indices, backedge_indices;
+    frontedge_indices.resize(orig_size, NULL_VALUE);
+    backedge_indices.resize(orig_size, NULL_VALUE);
+
+
+    for(osg::Geometry::PrimitiveSetList::iterator itr = orig_primitives.begin();
+        itr != orig_primitives.end();
+        ++itr)
+    {
+        osg::DrawElementsUShort* edging = new osg::DrawElementsUShort(osg::PrimitiveSet::QUAD_STRIP);
+        edging->setName("wall");
+        text_geometry->addPrimitiveSet(edging);
+
+        osg::DrawElementsUShort* elements = dynamic_cast<osg::DrawElementsUShort*>(itr->get());
+        if (elements)
+        {
+            for(unsigned int i=0; i<elements->size(); ++i)
+            {
+                unsigned int ei = (*elements)[i];
+                if (frontedge_indices[ei]==NULL_VALUE)
+                {
+                    frontedge_indices[ei] = vertices->size();
+                    vertices->push_back((*orig_vertices)[ei]);
+                }
+                if (backedge_indices[ei]==NULL_VALUE)
+                {
+                    backedge_indices[ei] = vertices->size();
+                    vertices->push_back((*orig_vertices)[ei]+forward);
+                }
+
+                edging->push_back(backedge_indices[ei]);
+                edging->push_back(frontedge_indices[ei]);
+            }
+        }
+    }
+
+    return text_geometry.release();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// computeTextGeometry
+//
+osg::Geometry* computeTextGeometry(osg::Geometry* glyphGeometry, const osgText::Bevel& profile, float width)
+{
+    osg::Vec3Array* orig_vertices = dynamic_cast<osg::Vec3Array*>(glyphGeometry->getVertexArray());
+    if (!orig_vertices)
+    {
+        OSG_NOTICE<<"computeTextGeometry(..): No vertices on glyphGeometry."<<std::endl;
+        return 0;
+    }
+
+    osg::ref_ptr<osg::Geometry> text_geometry = new osg::Geometry;
+    osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
+    text_geometry->setVertexArray(vertices.get());
+
+    typedef std::vector<unsigned int> Indices;
+    const unsigned int NULL_VALUE = UINT_MAX;
+    Indices front_indices, back_indices;
+    front_indices.resize(orig_vertices->size(), NULL_VALUE);
+    back_indices.resize(orig_vertices->size(), NULL_VALUE);
+
+    osg::DrawElementsUShort* face = 0;
+    osg::Geometry::PrimitiveSetList bevelPrimitiveSets;
+    osg::Vec3 forward(0,0,-width);
+
+    // collect bevels and face primitive sets
+    for(osg::Geometry::PrimitiveSetList::iterator itr = glyphGeometry->getPrimitiveSetList().begin();
+        itr != glyphGeometry->getPrimitiveSetList().end();
+        ++itr)
+    {
+        osg::PrimitiveSet* prim = itr->get();
+        if (prim->getName()=="face") face = dynamic_cast<osg::DrawElementsUShort*>(prim);
+        else if (prim->getName()=="bevel") bevelPrimitiveSets.push_back(prim);
+    }
+
+    // if we don't have a face we can't create any 3d text
+    if (!face) return 0;
+
+    // build up the vertices primitives for the front face, and record the indices
+    // for later use, and to ensure sharing of vertices in the face primitive set
+    osg::DrawElementsUShort* frontFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    text_geometry->addPrimitiveSet(frontFace);
+    for(unsigned int i=0; i<face->size();)
+    {
+        unsigned int pi = (*face)[i++];
+        if (front_indices[pi]==NULL_VALUE)
+        {
+            front_indices[pi] = vertices->size();
+            vertices->push_back((*orig_vertices)[pi]);
+        }
+        frontFace->push_back(front_indices[pi]);
+    }
+
+
+    // build up the vertices primitives for the back face, and record the indices
+    // for later use, and to ensure sharing of vertices in the face primitive set
+    // the order of the triangle indices are flipped to make sure that the triangles are back face
+    osg::DrawElementsUShort* backFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    text_geometry->addPrimitiveSet(backFace);
+    for(unsigned int i=0; i<face->size()-2;)
+    {
+        unsigned int p1 = (*face)[i++];
+        unsigned int p2 = (*face)[i++];
+        unsigned int p3 = (*face)[i++];
+        if (back_indices[p1]==NULL_VALUE)
+        {
+            back_indices[p1] = vertices->size();
+            vertices->push_back((*orig_vertices)[p1]+forward);
+        }
+
+        if (back_indices[p2]==NULL_VALUE)
+        {
+            back_indices[p2] = vertices->size();
+            vertices->push_back((*orig_vertices)[p2]+forward);
+        }
+
+        if (back_indices[p3]==NULL_VALUE)
+        {
+            back_indices[p3] = vertices->size();
+            vertices->push_back((*orig_vertices)[p3]+forward);
+        }
+
+        backFace->push_back(back_indices[p1]);
+        backFace->push_back(back_indices[p3]);
+        backFace->push_back(back_indices[p2]);
+    }
+
+    bool shareVerticesWithFaces = true;
+
+    // now build up the bevel
+    for(osg::Geometry::PrimitiveSetList::iterator itr = bevelPrimitiveSets.begin();
+        itr != bevelPrimitiveSets.end();
+        ++itr)
+    {
+        osg::DrawElementsUShort* bevel = dynamic_cast<osg::DrawElementsUShort*>(itr->get());
+        if (!bevel) continue;
+
+        unsigned int no_vertices_on_boundary = bevel->size()/2;
+
+        const osgText::Bevel::Vertices& profileVertices = profile.getVertices();
+        unsigned int no_vertices_on_bevel = profileVertices.size();
+
+        Indices bevelIndices;
+        bevelIndices.resize(no_vertices_on_boundary*no_vertices_on_bevel, NULL_VALUE);
+
+        // populate vertices
+        for(unsigned int i=0; i<no_vertices_on_boundary; ++i)
+        {
+            unsigned int topi = (*bevel)[i*2];
+            unsigned int basei = (*bevel)[i*2+1];
+
+            osg::Vec3& top_vertex = (*orig_vertices)[ topi ];
+            osg::Vec3& base_vertex = (*orig_vertices)[ basei ];
+            osg::Vec3 up = top_vertex-base_vertex;
+
+            if (shareVerticesWithFaces)
+            {
+                if (front_indices[basei]==NULL_VALUE)
+                {
+                    front_indices[basei] = vertices->size();
+                    vertices->push_back(base_vertex);
+                }
+
+                bevelIndices[i*no_vertices_on_bevel + 0] = front_indices[basei];
+
+                for(unsigned int j=1; j<no_vertices_on_bevel-1; ++j)
+                {
+                    const osg::Vec2& pv = profileVertices[j];
+                    osg::Vec3 pos( base_vertex + (forward * pv.x()) + (up * pv.y()) );
+                    bevelIndices[i*no_vertices_on_bevel + j] = vertices->size();
+                    vertices->push_back(pos);
+                }
+
+                if (back_indices[basei]==NULL_VALUE)
+                {
+                    back_indices[basei] = vertices->size();
+                    vertices->push_back(base_vertex + forward);
+                }
+
+                bevelIndices[i*no_vertices_on_bevel + no_vertices_on_bevel-1] = back_indices[basei];
+            }
+            else
+            {
+                for(unsigned int j=0; j<no_vertices_on_bevel; ++j)
+                {
+                    const osg::Vec2& pv = profileVertices[j];
+                    osg::Vec3 pos( base_vertex + (forward * pv.x()) + (up * pv.y()) );
+                    bevelIndices[i*no_vertices_on_bevel + j] = vertices->size();
+                    vertices->push_back(pos);
+                }
+            }
+        }
+
+        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(GL_TRIANGLES);
+        unsigned int base, next;
+        for(unsigned int i = 0; i< no_vertices_on_boundary-1; ++i)
+        {
+            for(unsigned int j=0; j<no_vertices_on_bevel-1; ++j)
+            {
+                base = i*no_vertices_on_bevel + j;
+                next = base + no_vertices_on_bevel;
+
+                elements->push_back(bevelIndices[base]);
+                elements->push_back(bevelIndices[next]);
+                elements->push_back(bevelIndices[base+1]);
+
+                elements->push_back(bevelIndices[base+1]);
+                elements->push_back(bevelIndices[next]);
+                elements->push_back(bevelIndices[next+1]);
+            }
+        }
+
+        text_geometry->addPrimitiveSet(elements);
+    }
+
+    return text_geometry.release();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// computeShellGeometry
+//
+osg::Geometry* computeShellGeometry(osg::Geometry* glyphGeometry, const osgText::Bevel& profile, float width)
+{
+    osg::Vec3Array* orig_vertices = dynamic_cast<osg::Vec3Array*>(glyphGeometry->getVertexArray());
+    if (!orig_vertices)
+    {
+        OSG_NOTICE<<"computeTextGeometry(..): No vertices on glyphGeometry."<<std::endl;
+        return 0;
+    }
+
+    osg::ref_ptr<osg::Geometry> text_geometry = new osg::Geometry;
+    osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
+    text_geometry->setVertexArray(vertices.get());
+
+    typedef std::vector<unsigned int> Indices;
+    const unsigned int NULL_VALUE = UINT_MAX;
+    Indices front_indices, back_indices;
+    front_indices.resize(orig_vertices->size(), NULL_VALUE);
+    back_indices.resize(orig_vertices->size(), NULL_VALUE);
+
+    osg::DrawElementsUShort* face = 0;
+    osg::Geometry::PrimitiveSetList bevelPrimitiveSets;
+    osg::Geometry::PrimitiveSetList shellPrimitiveSets;
+    osg::Vec3 frontOffset(0,0,width);
+    osg::Vec3 backOffset(0,0,-2.0*width);
+    osg::Vec3 forward(backOffset-frontOffset);
+
+    // collect bevels and face primitive sets
+    for(osg::Geometry::PrimitiveSetList::iterator itr = glyphGeometry->getPrimitiveSetList().begin();
+        itr != glyphGeometry->getPrimitiveSetList().end();
+        ++itr)
+    {
+        osg::PrimitiveSet* prim = itr->get();
+        if (prim->getName()=="face") face = dynamic_cast<osg::DrawElementsUShort*>(prim);
+        else if (prim->getName()=="bevel") bevelPrimitiveSets.push_back(prim);
+        else if (prim->getName()=="shell") shellPrimitiveSets.push_back(prim);
+    }
+
+    // if we don't have a face we can't create any 3d text
+    if (!face) return 0;
+
+    // build up the vertices primitives for the front face, and record the indices
+    // for later use, and to ensure sharing of vertices in the face primitive set
+    // the order of the triangle indices are flipped to make sure that the triangles are back face
+    osg::DrawElementsUShort* frontFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    text_geometry->addPrimitiveSet(frontFace);
+    for(unsigned int i=0; i<face->size()-2;)
+    {
+        unsigned int p1 = (*face)[i++];
+        unsigned int p2 = (*face)[i++];
+        unsigned int p3 = (*face)[i++];
+        if (front_indices[p1]==NULL_VALUE)
+        {
+            front_indices[p1] = vertices->size();
+            vertices->push_back((*orig_vertices)[p1]+frontOffset);
+        }
+
+        if (front_indices[p2]==NULL_VALUE)
+        {
+            front_indices[p2] = vertices->size();
+            vertices->push_back((*orig_vertices)[p2]+frontOffset);
+        }
+
+        if (front_indices[p3]==NULL_VALUE)
+        {
+            front_indices[p3] = vertices->size();
+            vertices->push_back((*orig_vertices)[p3]+frontOffset);
+        }
+
+        frontFace->push_back(front_indices[p1]);
+        frontFace->push_back(front_indices[p3]);
+        frontFace->push_back(front_indices[p2]);
+    }
+
+
+    // build up the vertices primitives for the back face, and record the indices
+    // for later use, and to ensure sharing of vertices in the face primitive set
+    osg::DrawElementsUShort* backFace = new osg::DrawElementsUShort(GL_TRIANGLES);
+    text_geometry->addPrimitiveSet(backFace);
+    for(unsigned int i=0; i<face->size();)
+    {
+        unsigned int pi = (*face)[i++];
+        if (back_indices[pi]==NULL_VALUE)
+        {
+            back_indices[pi] = vertices->size();
+            vertices->push_back((*orig_vertices)[pi]+backOffset);
+        }
+        backFace->push_back(back_indices[pi]);
+    }
+
+    for(osg::Geometry::PrimitiveSetList::iterator itr = bevelPrimitiveSets.begin();
+        itr != bevelPrimitiveSets.end();
+        ++itr)
+    {
+        osg::DrawElementsUShort* strip = dynamic_cast<osg::DrawElementsUShort*>(itr->get());
+        if (!strip) continue;
+
+        osg::CopyOp copyop(osg::CopyOp::DEEP_COPY_ALL);
+
+        osg::DrawElementsUShort* front_strip = dynamic_cast<osg::DrawElementsUShort*>(copyop(strip));
+        text_geometry->addPrimitiveSet(front_strip);
+        for(unsigned int i=0; i<front_strip->size(); ++i)
+        {
+            unsigned short& pi  = (*front_strip)[i];
+            if (front_indices[pi]==NULL_VALUE)
+            {
+                front_indices[pi] = vertices->size();
+                vertices->push_back((*orig_vertices)[pi]+frontOffset);
+            }
+            pi = front_indices[pi]; 
+        }
+
+        for(unsigned int i=0; i<front_strip->size()-1;)
+        {
+            unsigned short& p1  = (*front_strip)[i++];
+            unsigned short& p2  = (*front_strip)[i++];
+            std::swap(p1,p2);
+        }
+
+        osg::DrawElementsUShort* back_strip = dynamic_cast<osg::DrawElementsUShort*>(copyop(strip));
+        text_geometry->addPrimitiveSet(back_strip);
+        for(unsigned int i=0; i<back_strip->size(); ++i)
+        {
+            unsigned short& pi  = (*back_strip)[i];
+            if (back_indices[pi]==NULL_VALUE)
+            {
+                back_indices[pi] = vertices->size();
+                vertices->push_back((*orig_vertices)[pi]+backOffset);
+            }
+            pi = back_indices[pi];
+        }
+    }
+
+
+    // now build up the shell
+    for(osg::Geometry::PrimitiveSetList::iterator itr = shellPrimitiveSets.begin();
+        itr != shellPrimitiveSets.end();
+        ++itr)
+    {
+        osg::DrawElementsUShort* bevel = dynamic_cast<osg::DrawElementsUShort*>(itr->get());
+        if (!bevel) continue;
+
+        unsigned int no_vertices_on_boundary = bevel->size()/2;
+
+        const osgText::Bevel::Vertices& profileVertices = profile.getVertices();
+        unsigned int no_vertices_on_bevel = profileVertices.size();
+
+        Indices bevelIndices;
+        bevelIndices.resize(no_vertices_on_boundary*no_vertices_on_bevel, NULL_VALUE);
+
+        // populate vertices
+        for(unsigned int i=0; i<no_vertices_on_boundary; ++i)
+        {
+            unsigned int topi = (*bevel)[i*2+1];
+            unsigned int basei = (*bevel)[i*2];
+
+            osg::Vec3 top_vertex = (*orig_vertices)[ topi ] + frontOffset;
+            osg::Vec3 base_vertex = (*orig_vertices)[ basei ] + frontOffset;
+            osg::Vec3 up = top_vertex-base_vertex;
+
+            if (front_indices[basei]==NULL_VALUE)
+            {
+                front_indices[basei] = vertices->size();
+                vertices->push_back(base_vertex);
+            }
+
+            bevelIndices[i*no_vertices_on_bevel + 0] = front_indices[basei];
+
+            for(unsigned int j=1; j<no_vertices_on_bevel-1; ++j)
+            {
+                const osg::Vec2& pv = profileVertices[j];
+                osg::Vec3 pos( base_vertex + (forward * pv.x()) + (up * pv.y()) );
+                bevelIndices[i*no_vertices_on_bevel + j] = vertices->size();
+                vertices->push_back(pos);
+            }
+
+            if (back_indices[basei]==NULL_VALUE)
+            {
+                back_indices[basei] = vertices->size();
+                vertices->push_back(base_vertex + forward);
+            }
+
+            bevelIndices[i*no_vertices_on_bevel + no_vertices_on_bevel-1] = back_indices[basei];
+        }
+
+        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(GL_TRIANGLES);
+        unsigned int base, next;
+        for(unsigned int i = 0; i< no_vertices_on_boundary-1; ++i)
+        {
+            for(unsigned int j=0; j<no_vertices_on_bevel-1; ++j)
+            {
+                base = i*no_vertices_on_bevel + j;
+                next = base + no_vertices_on_bevel;
+
+                elements->push_back(bevelIndices[base]);
+                elements->push_back(bevelIndices[base+1]);
+                elements->push_back(bevelIndices[next]);
+
+                elements->push_back(bevelIndices[base+1]);
+                elements->push_back(bevelIndices[next+1]);
+                elements->push_back(bevelIndices[next]);
+            }
+        }
+
+        text_geometry->addPrimitiveSet(elements);
+    }
+
+#if 1
+    osg::Vec4Array* new_colours = new osg::Vec4Array;
+    new_colours->push_back(osg::Vec4(1.0,1.0,1.0,0.2));
+    text_geometry->setColorArray(new_colours);
+    text_geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
+
+
+    osg::StateSet* stateset = text_geometry->getOrCreateStateSet();
+    stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
+    stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
+    stateset->setAttributeAndModes(new osg::CullFace, osg::StateAttribute::ON);
+    //stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
+    stateset->setRenderBinDetails(11, "SORT_FRONT_TO_BACK");
+#endif
+    return text_geometry.release();
+}
+
+}
\ No newline at end of file
diff --git a/src/osgText/GlyphGeometry.h b/src/osgText/GlyphGeometry.h
new file mode 100644
index 000000000..87a63bc72
--- /dev/null
+++ b/src/osgText/GlyphGeometry.h
@@ -0,0 +1,32 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library 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
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef OSGTEXT_GLYPHGEOMETRY
+#define OSGTEXT_GLYPHGEOMETRY 1
+
+#include <osgText/TextNode>
+
+namespace osgText
+{
+
+extern osg::Geometry* computeGlyphGeometry(osgText::Glyph3D* glyph, float bevelThickness, float shellThickness);
+
+extern osg::Geometry* computeTextGeometry(osgText::Glyph3D* glyph, float width);
+
+extern osg::Geometry* computeTextGeometry(osg::Geometry* glyphGeometry, const Bevel& profile, float width);
+
+extern osg::Geometry* computeShellGeometry(osg::Geometry* glyphGeometry, const Bevel& profile, float width);
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/osgText/TextNode.cpp b/src/osgText/TextNode.cpp
new file mode 100644
index 000000000..f29900419
--- /dev/null
+++ b/src/osgText/TextNode.cpp
@@ -0,0 +1,425 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library 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
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include <osgText/TextNode>
+#include "GlyphGeometry.h"
+
+#include <osg/PositionAttitudeTransform>
+#include <osg/Geode>
+#include <osgUtil/SmoothingVisitor>
+
+#include <osg/io_utils>
+
+using namespace osgText;
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// Bevel
+//
+Bevel::Bevel()
+{
+    _thickness = 0.02f;
+    flatBevel();
+}
+
+Bevel::Bevel(const Bevel& bevel, const osg::CopyOp&):
+    _thickness(bevel._thickness),
+    _vertices(bevel._vertices)
+{
+}
+
+void Bevel::flatBevel(float width)
+{
+    _vertices.clear();
+
+    if (width>0.5f) width = 0.5f;
+
+    _vertices.push_back(osg::Vec2(0.0f,0.0f));
+
+    _vertices.push_back(osg::Vec2(width,1.0f));
+
+    if (width<0.5f) _vertices.push_back(osg::Vec2(1-width,1.0f));
+
+    _vertices.push_back(osg::Vec2(1.0f,0.0f));
+}
+
+void Bevel::roundedBevel(float width, unsigned int numSteps)
+{
+    _vertices.clear();
+
+    if (width>0.5f) width = 0.5f;
+
+    unsigned int i = 0;
+    for(; i<=numSteps; ++i)
+    {
+        float angle = float(osg::PI)*0.5f*(float(i)/float(numSteps));
+        _vertices.push_back( osg::Vec2((1.0f-cosf(angle))*width, sinf(angle)) );
+    }
+
+    // start the second half one into the curve if the width is half way across
+    i = width<0.5f ? 0 : 1;
+    for(; i<=numSteps; ++i)
+    {
+        float angle = float(osg::PI)*0.5f*(float(numSteps-i)/float(numSteps));
+        _vertices.push_back( osg::Vec2(1.0-(1.0f-cosf(angle))*width, sin(angle)) );
+    }
+}
+
+void Bevel::roundedBevel2(float width, unsigned int numSteps)
+{
+    _vertices.clear();
+
+    if (width>0.5f) width = 0.5f;
+
+    float h = 0.1f;
+    float r = 1.0f-h;
+
+    _vertices.push_back(osg::Vec2(0.0,0.0));
+
+    unsigned int i = 0;
+    for(; i<=numSteps; ++i)
+    {
+        float angle = float(osg::PI)*0.5f*(float(i)/float(numSteps));
+        _vertices.push_back( osg::Vec2((1.0f-cosf(angle))*width, h + sinf(angle)*r) );
+    }
+
+    // start the second half one into the curve if the width is half way across
+    i = width<0.5f ? 0 : 1;
+    for(; i<=numSteps; ++i)
+    {
+        float angle = float(osg::PI)*0.5f*(float(numSteps-i)/float(numSteps));
+        _vertices.push_back( osg::Vec2(1.0-(1.0f-cosf(angle))*width, h + sin(angle)*r) );
+    }
+
+    _vertices.push_back(osg::Vec2(1.0,0.0));
+
+}
+
+void Bevel::print(std::ostream& fout)
+{
+    OSG_NOTICE<<"print bevel"<<std::endl;
+    for(Vertices::iterator itr = _vertices.begin();
+        itr != _vertices.end();
+        ++itr)
+    {
+        OSG_NOTICE<<"  "<<*itr<<std::endl;
+    }
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// Style
+//
+Style::Style():
+    _widthRatio(1.0f),
+    _thicknessRatio(0.0f),
+    _outlineRatio(0.0f),
+    _sampleDensity(1.0f)
+{
+}
+
+Style::Style(const Style& style, const osg::CopyOp& copyop):
+    osg::Object(style,copyop),
+    _bevel(dynamic_cast<Bevel*>(copyop(style._bevel.get()))),
+    _widthRatio(style._widthRatio),
+    _thicknessRatio(style._thicknessRatio),
+    _outlineRatio(style._outlineRatio),
+    _sampleDensity(style._sampleDensity)
+{
+}
+
+/// default Layout implementation used if no other is specified on TextNode
+osg::ref_ptr<Style>& Style::getDefaultStyle()
+{
+    static OpenThreads::Mutex s_DefaultStyleMutex;
+    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_DefaultStyleMutex);
+
+    static osg::ref_ptr<Style> s_defaultStyle = new Style;
+    return s_defaultStyle;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// Layout
+//
+Layout::Layout()
+{
+}
+
+Layout::Layout(const Layout& layout, const osg::CopyOp& copyop):
+    osg::Object(layout,copyop)
+{
+}
+
+osg::ref_ptr<Layout>& Layout::getDefaultLayout()
+{
+    static OpenThreads::Mutex s_DefaultLayoutMutex;
+    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_DefaultLayoutMutex);
+
+    static osg::ref_ptr<Layout> s_defaultLayout = new Layout;
+    return s_defaultLayout;
+}
+
+void Layout::layout(TextNode& text) const
+{
+    OSG_NOTICE<<"Layout::layout"<<std::endl;
+
+    Font* font = text.getActiveFont();
+    Style* style = text.getActiveStyle();
+    TextTechnique* technique = text.getTextTechnique();
+    const String& str = text.getText();
+
+    if (!text.getTextTechnique())
+    {
+        OSG_NOTICE<<"Warning: no TextTechnique assigned to Layout"<<std::endl;
+        return;
+    }
+
+    osg::Vec3 pos(0.0f,0.0f,0.0f);
+    float characterSize = text.getCharacterSize();
+    osg::Vec3 size(characterSize, characterSize, 0.0);
+    if (style)
+    {
+        size.y() = characterSize;
+        size.z() = characterSize;
+    }
+
+
+    osgText::FontResolution resolution(32,32);
+    if (style)
+    {
+        resolution.first = static_cast<unsigned int>(static_cast<float>(resolution.first)*style->getSampleDensity());
+        resolution.second = static_cast<unsigned int>(static_cast<float>(resolution.second)*style->getSampleDensity());
+    }
+
+    float characterWidthScale = 1.0f;
+    float characterHeightScale = 1.0f;
+
+    bool textIs3D = (style && style->getThicknessRatio()!=0.0);
+    if (textIs3D)
+    {
+        characterWidthScale = font->getScale();
+        characterHeightScale = font->getScale();
+    }
+    else
+    {
+        characterWidthScale = 1.0f/static_cast<float>(resolution.first);
+        characterHeightScale = 1.0f/static_cast<float>(resolution.second);
+    }
+
+    osgText::KerningType kerningType = osgText::KERNING_DEFAULT;
+
+    technique->start();
+
+    unsigned int previousCharcode = 0;
+    for(unsigned int i=0; i<str.size(); ++i)
+    {
+        unsigned int charcode = str[i];
+
+        if (size.z()==0.0f)
+        {
+            osgText::Glyph* glyph = font->getGlyph(resolution, charcode);
+            if (glyph)
+            {
+                technique->addCharacter(pos, size, glyph, style);
+                pos += osg::Vec3(size.x()*(glyph->getHorizontalAdvance()*characterWidthScale), 0.0f ,0.0f);
+            }
+        }
+        else
+        {
+            osgText::Glyph3D* glyph = font->getGlyph3D(charcode);
+            OSG_NOTICE<<"pos = "<<pos<<", charcode="<<charcode<<", glyph="<<glyph<< std::endl;
+            if (glyph)
+            {
+                osg::Vec3 local_scale( size );
+                local_scale *= (1.0f/font->getScale());
+
+                technique->addCharacter(pos, local_scale, glyph, style);
+                pos += osg::Vec3(size.x()*(glyph->getHorizontalWidth()/font->getScale()), 0.0f ,0.0f);
+            }
+        }
+
+        if (previousCharcode!=0 && charcode!=0)
+        {
+            osg::Vec2 offset = font->getKerning(previousCharcode, charcode, kerningType);
+            OSG_NOTICE<<"  offset = "<<offset<< std::endl;
+            pos.x() += offset.x();
+            pos.y() += offset.y();
+        }
+
+        previousCharcode = charcode;
+    }
+
+    technique->finish();
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// TextTechnique
+//
+TextTechnique::TextTechnique():
+    _textNode(0)
+{
+}
+
+
+TextTechnique::TextTechnique(const TextTechnique& technique, const osg::CopyOp& copyop):
+    osg::Object(technique, copyop),
+    _textNode(0)
+{
+}
+
+osg::ref_ptr<TextTechnique>& TextTechnique::getDefaultTextTechinque()
+{
+    static OpenThreads::Mutex s_DefaultTextTechniqueMutex;
+    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_DefaultTextTechniqueMutex);
+
+    static osg::ref_ptr<TextTechnique> s_defaultTextTechnique = new TextTechnique;
+    return s_defaultTextTechnique;
+}
+
+void TextTechnique::start()
+{
+    OSG_NOTICE<<"TextTechnique::start()"<<std::endl;
+}
+
+void TextTechnique::addCharacter(const osg::Vec3& position, const osg::Vec3& size, Glyph* glyph, Style* style)
+{
+    OSG_NOTICE<<"TextTechnique::addCharacter 2D("<<position<<", "<<size<<", "<<glyph<<", "<<style<<")"<<std::endl;
+}
+
+void TextTechnique::addCharacter(const osg::Vec3& position, const osg::Vec3& size, Glyph3D* glyph, Style* style)
+{
+    OSG_NOTICE<<"TextTechnique::addCharacter 3D("<<position<<", "<<size<<", "<<glyph<<", "<<style<<")"<<std::endl;
+
+    osg::ref_ptr<osg::PositionAttitudeTransform> transform = new osg::PositionAttitudeTransform;
+    transform->setPosition(position);
+    transform->setAttitude(osg::Quat(osg::inDegrees(90.0),osg::Vec3d(1.0,0.0,0.0)));
+    transform->setScale(size);
+
+    osg::ref_ptr<osg::Geode> geode = new osg::Geode;
+
+    const Bevel* bevel = style ? style->getBevel() : 0;
+    bool outline = style ? style->getOutlineRatio()>0.0f : false;
+    float width = style->getThicknessRatio();
+    float creaseAngle = 30.0f;
+    bool smooth = true;
+
+    if (bevel)
+    {
+        float thickness = bevel->getBevelThickness();
+
+        osg::ref_ptr<osg::Geometry> glyphGeometry = osgText::computeGlyphGeometry(glyph, thickness, width);
+        osg::ref_ptr<osg::Geometry> textGeometry = osgText::computeTextGeometry(glyphGeometry.get(), *bevel, width);
+        osg::ref_ptr<osg::Geometry> shellGeometry = outline ? osgText::computeShellGeometry(glyphGeometry.get(), *bevel, width) : 0;
+        if (textGeometry.valid()) geode->addDrawable(textGeometry.get());
+        if (shellGeometry.valid()) geode->addDrawable(shellGeometry.get());
+
+        // create the normals
+        if (smooth && textGeometry.valid())
+        {
+            osgUtil::SmoothingVisitor::smooth(*textGeometry, osg::DegreesToRadians(creaseAngle));
+        }
+    }
+    else
+    {
+        osg::ref_ptr<osg::Geometry> textGeometry = osgText::computeTextGeometry(glyph, width);
+        if (textGeometry.valid()) geode->addDrawable(textGeometry.get());
+
+        // create the normals
+        if (smooth && textGeometry.valid())
+        {
+            osgUtil::SmoothingVisitor::smooth(*textGeometry, osg::DegreesToRadians(creaseAngle));
+        }
+    }
+
+    transform->addChild(geode.get());
+
+    _textNode->addChild(transform.get());
+
+    transform->getOrCreateStateSet()->setMode(GL_NORMALIZE, osg::StateAttribute::ON);
+
+}
+
+void TextTechnique::finish()
+{
+    OSG_NOTICE<<"TextTechnique::finish()"<<std::endl;
+}
+
+void TextTechnique::traverse(osg::NodeVisitor& nv)
+{
+    // OSG_NOTICE<<"TextTechnique::traverse()"<<std::endl;
+    if (_textNode) _textNode->Group::traverse(nv);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//
+// TextNode
+//
+TextNode::TextNode():
+        _characterSize(1.0f)
+{
+}
+
+
+TextNode::TextNode(const TextNode& text, const osg::CopyOp& copyop):
+    osg::Group(text, copyop)
+{
+}
+
+TextNode::~TextNode()
+{
+    setTextTechnique(0);
+}
+
+void TextNode::traverse(osg::NodeVisitor& nv)
+{
+    if (_technique.valid())
+    {
+        _technique->traverse(nv);
+    }
+    else
+    {
+        Group::traverse(nv);
+    }
+}
+
+void TextNode::setTextTechnique(TextTechnique* technique)
+{
+    if (_technique==technique) return;
+
+    if (_technique.valid()) _technique->setTextNode(0);
+
+    if (TextTechnique::getDefaultTextTechinque()==technique)
+    {
+        OSG_NOTICE<<"Warning: Attempt to assign DefaultTextTechnique() prototype to TextNode::setTextTechnique(..), assigning a clone() of it instead."<<std::endl;
+        technique = new TextTechnique(*TextTechnique::getDefaultTextTechinque());
+    }
+
+    _technique = technique;
+
+    if (_technique.valid()) _technique->setTextNode(this);
+}
+
+
+void TextNode::update()
+{
+    getActiveLayout()->layout(*this);
+}
+
+void TextNode::setText(const std::string& str)
+{
+    _string.set(str);
+}