osg::TextVectorFace Class Reference

#include <OSGTextVectorFace.h>

Inheritance diagram for osg::TextVectorFace:

List of all members.

Public Types
enum	Style { STYLE_PLAIN, STYLE_BOLD, STYLE_ITALIC, STYLE_BOLDITALIC }
Public Member Functions
virtual const TextGlyph &	getGlyph (TextGlyph::Index glyphIndex)
const TextVectorGlyph &	getVectorGlyph (TextGlyph::Index glyphIndex)
void	fillGeo (GeometryPtr &geoPtr, const TextLayoutResult &layoutResult, Real32 scale=1.f, Real32 depth=0.f, UInt32 level=2, Real32 creaseAngle=Pi/4.f)
GeometryPtr	makeGeo (const TextLayoutResult &layoutResult, Real32 scale=1.f, Real32 depth=0.f, UInt32 level=2, Real32 creaseAngle=Pi/4.f)
NodePtr	makeNode (const TextLayoutResult &layoutResult, Real32 scale=1.f, Real32 depth=0.f, UInt32 level=2, Real32 creaseAngle=Pi/4.f)
const std::string	getFamily () const
Style	getStyle () const
Real32	getHoriAscent () const
Real32	getVertAscent () const
Real32	getHoriDescent () const
Real32	getVertDescent () const
virtual void	layout (const std::string &utf8Text, const TextLayoutParam &param, TextLayoutResult &result)
virtual void	layout (const std::wstring &text, const TextLayoutParam &param, TextLayoutResult &result)=0
virtual void	layout (const std::vector< std::string > &lines, const TextLayoutParam &param, TextLayoutResult &result)
virtual void	layout (const std::vector< std::wstring > &lines, const TextLayoutParam &param, TextLayoutResult &result)
void	calculateBoundingBox (const TextLayoutResult &layoutResult, Vec2f &lowerLeft, Vec2f &upperRight)
Reference Counting
*void	addRef (void)
void	subRef (void)
Int32	getRefCount (void)
Reference Counting
*void	addRef (void)
void	subRef (void)
Int32	getRefCount (void)
Static Public Member Functions
static TextVectorFace *	create (const std::string &family, Style style=STYLE_PLAIN)
static void	convertUTF8ToUnicode (const std::string &utf8Text, std::wstring &text)
Protected Types
typedef std::map< TextGlyph::Index, TextVectorGlyph * >	GlyphMap
Protected Member Functions
	TextVectorFace ()
virtual	~TextVectorFace ()
virtual std::auto_ptr< TextVectorGlyph >	createGlyph (TextGlyph::Index glyphIndex)=0
void	justifyLine (const TextLayoutParam &param, const std::vector< UInt32 > &spaceIndices, Vec2f &currPos, TextLayoutResult &layoutResult) const
void	adjustLineOrigin (const TextLayoutParam &param, const Vec2f &currPos, TextLayoutResult &layoutResult) const
Protected Attributes
Real32	_scale
GlyphMap	_glyphMap
std::string	_family
Style	_style
Real32	_horiAscent
Real32	_vertAscent
Real32	_horiDescent
Real32	_vertDescent
Static Protected Attributes
static TextVectorGlyph	_emptyGlyph
Private Member Functions
	TextVectorFace (const TextVectorFace &)
const TextVectorFace &	operator= (const TextVectorFace &)

---

Detailed Description

Represents a vector face. A vector face allows to create texts as 3D objects. The following piece of code demonstrates how to create and use TextVectorFace objects.

 // Includes
 #include "OSGTextVectorFace.h"
 #include "OSGTextLayoutParam.h"
 #include "OSGTextLayoutResult.h"

 // Try to create a new %TextVectorFace object. The create
 // method returns 0 in case of an error
 TextVectorFace *face = TextVectorFace::create("SANS");
 if (face == 0)
   ; // error handling

 // Increment the reference counter of the face object.
 // Faces are cached, and we might not be the only one
 // using the face object
 addRefP(face);

 // Lay out a single line of text. There are lots of parameters
 // you can set in the layoutParam object, but for now we are
 // satisfied with the default values. See the documentation
 // of the TextLayoutParam class for more information.
 TextLayoutParam layoutParam;
 TextLayoutResult layoutResult;
 face->layout("Hello World!", layoutParam, layoutResult);

 // Create the geometry using the layout information returned
 // from the previous call to the layout method.
 Real32 scale = 2.f;  // This is the height of the glyphs
 Real32 depth = 0.5f; // This is the depth of the glyphs
 GeometryPtr geo = face->makeGeo(layoutResult, scale, depth);

 // We do not need the vector face anymore, so decrement
 // the reference counter. Do not use the face object anymore!
 subRefP(face);

Author:

Patrick Dähne

Definition at line 111 of file OSGTextVectorFace.h.

---

Member Typedef Documentation

typedef std::map<TextGlyph::Index, TextVectorGlyph*> osg::TextVectorFace::GlyphMap [protected]

Defines a map of glyphs Definition at line 206 of file OSGTextVectorFace.h.

---

Member Enumeration Documentation

enum osg::TextFace::Style [inherited]

Defines the styles of a face Enumerator: STYLE_PLAIN  STYLE_BOLD  STYLE_ITALIC  STYLE_BOLDITALIC  Definition at line 75 of file OSGTextFace.h. { STYLE_PLAIN, STYLE_BOLD, STYLE_ITALIC, STYLE_BOLDITALIC };

---

Constructor & Destructor Documentation

osg::TextVectorFace::TextVectorFace (   )  [inline, protected]

Creates a new TextVectorFace object. Definition at line 43 of file OSGTextVectorFace.inl. : TextFace(), _scale(), _glyphMap() {}

osg::TextVectorFace::~TextVectorFace (   )  [protected, virtual]

Destroys the TextVectorFace object. Definition at line 72 of file OSGTextVectorFace.cpp. References _glyphMap. { // Delete all glyphs in the glyph cache GlyphMap::iterator it; for (it = _glyphMap.begin(); it != _glyphMap.end(); ++it) { assert(it->second != 0); delete it->second; } }

osg::TextVectorFace::TextVectorFace (  const TextVectorFace &   )  [private]

Copy constructor (not implemented!)

---

Member Function Documentation

const TextGlyph & osg::TextVectorFace::getGlyph (  TextGlyph::Index  glyphIndex  )  [virtual]

Returns information about a glyph. Parameters: glyphIndex  The index of the glyph. Use the layout method to get the glyph indices corresponding to a character string. Returns: A glyph object containing information about the glyph. Implements osg::TextFace. Definition at line 88 of file OSGTextVectorFace.cpp. References getVectorGlyph(). { return getVectorGlyph(glyphIndex); }

const TextVectorGlyph & osg::TextVectorFace::getVectorGlyph (  TextGlyph::Index  glyphIndex  )

Returns information about a glyph. Parameters: glyphIndex  The index of the glyph. Use the layout method to get the glyph indices corresponding to a character string. Returns: A glyph object containing information about the glyph. Definition at line 98 of file OSGTextVectorFace.cpp. References _emptyGlyph, _glyphMap, createGlyph(), and osg::TextGlyph::INVALID_INDEX. Referenced by fillGeo(), and getGlyph(). { if (glyphIndex == TextGlyph::INVALID_INDEX) return _emptyGlyph; // Try to find the glyph in the map of glyphs GlyphMap::const_iterator it = _glyphMap.find(glyphIndex); if (it != _glyphMap.end()) { assert(it->second != 0); return *(it->second); } // We did not find the glyph, so we have to create it auto_ptr<TextVectorGlyph> glyph = createGlyph(glyphIndex); // We could not create the glyph, return 0 if (glyph.get() == 0) return _emptyGlyph; // Put the glyph into the glyph cache _glyphMap.insert(GlyphMap::value_type(glyphIndex, glyph.get())); // Return the glyph return *(glyph.release()); }

void osg::TextVectorFace::fillGeo (  GeometryPtr &  geoPtr, const TextLayoutResult &  layoutResult, Real32  scale = 1.f, Real32  depth = 0.f, UInt32  level = 2, Real32  creaseAngle = Pi/4.f )

Fills a geometry with a new text. Parameters: geoPtr  The geometry that gets filled with the new text. layoutResult  The result of a layout operation. scale  The size of the glyphs. depth  The depth of the VectorGlyphs. If depth is 0.f no backside will be generated. level  The level of detail. Usually between 0 and 10. creaseAngle  The angle (in radians) which determines how faceted the glyphs should be lighted. If the angle enclosed by two vertex normals in a point exceeds the creaseAngle both of the two normals will be attached to the point. Otherwise their mean is used. Definition at line 130 of file OSGTextVectorFace.cpp. References osg::beginEditCP(), osg::TextVectorGlyph::CCW, osg::TextVectorGlyph::PolygonOutline::contours, osg::TextVectorGlyph::PolygonOutline::coords, osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::GeoProperty< GeoPropertyDesc >::GeoPropDataFieldMask, osg::TextVectorGlyph::getContourOrientations(), osg::TextVectorGlyph::getLines(), osg::TextVectorGlyph::getNormals(), osg::TextLayoutResult::getNumGlyphs(), getVectorGlyph(), GLenum, osg::TextVectorGlyph::PolygonOutline::indices, osg::TextLayoutResult::indices, osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::NullFC, osg::TextLayoutResult::positions, start, osg::TextVectorGlyph::PolygonOutline::types, osg::VecStorage2< ValueTypeT >::x(), and osg::VecStorage2< ValueTypeT >::y(). Referenced by makeGeo(). { beginEditCP(geoPtr); // cast the field containers down to the needed type and create them // when they have the wrong type GeoPositions3fPtr posPtr = GeoPositions3fPtr::dcast(geoPtr->getPositions()); if (posPtr == NullFC) { posPtr = GeoPositions3f::create(); geoPtr->setPositions(posPtr); } else posPtr->clear(); GeoNormals3fPtr normalsPtr = GeoNormals3fPtr::dcast(geoPtr->getNormals()); if (normalsPtr == NullFC) { normalsPtr = GeoNormals3f::create(); geoPtr->setNormals(normalsPtr); } else normalsPtr->clear(); GeoTexCoords2fPtr texPtr = GeoTexCoords2fPtr::dcast(geoPtr->getTexCoords()); if (texPtr == NullFC) { texPtr = GeoTexCoords2f::create(); geoPtr->setTexCoords(texPtr); } else texPtr->clear(); GeoPLengthsUI32Ptr lensPtr = GeoPLengthsUI32Ptr::dcast(geoPtr->getLengths()); if (lensPtr == NullFC) { lensPtr = GeoPLengthsUI32::create(); geoPtr->setLengths(lensPtr); } else lensPtr->clear(); GeoIndicesUI32Ptr indicesPtr = GeoIndicesUI32Ptr::dcast(geoPtr->getIndices()); if (indicesPtr == NullFC) { indicesPtr = GeoIndicesUI32::create(); geoPtr->setIndices(indicesPtr); } else indicesPtr->clear(); GeoPTypesUI8Ptr typesPtr = GeoPTypesUI8Ptr::dcast(geoPtr->getTypes()); if (typesPtr == NullFC) { typesPtr = GeoPTypesUI8::create(); geoPtr->setTypes(typesPtr); } else typesPtr->clear(); geoPtr->setColors(NullFC); geoPtr->setSecondaryColors(NullFC); geoPtr->setTexCoords1(NullFC); geoPtr->setTexCoords2(NullFC); geoPtr->setTexCoords3(NullFC); geoPtr->getIndexMapping().clear(); UInt32 numGlyphs = layoutResult.getNumGlyphs(); if (numGlyphs == 0) { endEditCP(geoPtr); return; } // the interleaved multi-index blocks have the layout // Position | Normal | TexCoord geoPtr->getIndexMapping().push_back(Geometry::MapPosition); geoPtr->getIndexMapping().push_back(Geometry::MapNormal); geoPtr->getIndexMapping().push_back(Geometry::MapTexCoords); beginEditCP(posPtr, GeoPositions3f::GeoPropDataFieldMask); beginEditCP(normalsPtr, GeoNormals3f::GeoPropDataFieldMask); beginEditCP(texPtr, GeoTexCoords2f::GeoPropDataFieldMask); beginEditCP(lensPtr, GeoPLengthsUI32::GeoPropDataFieldMask); beginEditCP(indicesPtr, GeoIndicesUI32::GeoPropDataFieldMask); beginEditCP(typesPtr, GeoPTypesUI8::GeoPropDataFieldMask); // store the normal for the front face normalsPtr->push_back(Vec3f(0.f, 0.f, 1.f)); if (depth > 0.f) // store the normal for the back face normalsPtr->push_back(Vec3f(0.f, 0.f, -1.f)); UInt32 i; for (i = 0; i < numGlyphs; ++i) { const TextVectorGlyph &glyph = getVectorGlyph(layoutResult.indices[i]); const TextVectorGlyph::PolygonOutline &outline = glyph.getLines(level); const Vec2f &pos = layoutResult.positions[i]; // add the front face to the geometry // store positions and texture coordinates UInt32 coordOffset = posPtr->size(); UInt32 texCoordOffset = texPtr->size(); Real32 coordZ = 0.5f * depth; vector<Vec2f>::const_iterator cIt; for (cIt = outline.coords.begin(); cIt != outline.coords.end(); ++cIt) { Vec2f coord = *cIt + pos; Vec2f texCoord = coord; coord *= scale; posPtr->push_back(Vec3f(coord.x(), coord.y(), coordZ)); texCoord -= layoutResult.positions.front(); texPtr->push_back(texCoord); } // Store types, lengths and indices vector<TextVectorGlyph::PolygonOutline::TypeIndex>::const_iterator tIt; UInt32 indexBegin = 0, indexEnd; for (tIt = outline.types.begin(); tIt != outline.types.end(); ++tIt) { typesPtr->push_back(tIt->first); indexEnd = tIt->second; assert(indexEnd >= indexBegin); lensPtr->push_back(indexEnd - indexBegin); UInt32 i; for (i = indexBegin; i < indexEnd; ++i) { // the interleaved multi-index blocks have the layout // Position | Normal | TexCoord assert(i < outline.indices.size()); UInt32 index = outline.indices[i]; assert(coordOffset + index < posPtr->size()); indicesPtr->push_back(coordOffset + index); indicesPtr->push_back(0); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); } indexBegin = indexEnd; } // add the back and side faces only if depth > 0 if (depth > 0.f) { // add the back face to the geometry // store positions // No need to store texture coordinates - we reuse the // texture coordinates from the front side UInt32 backCoordOffset = posPtr->size(); coordZ = -0.5f * depth; for (cIt = outline.coords.begin(); cIt != outline.coords.end(); ++cIt) { Vec2f coord = *cIt + pos; coord *= scale; posPtr->push_back(Vec3f(coord.x(), coord.y(), coordZ)); } // Store types, lengths and indices // We have to flip all triangles to enable correct backface culling. // For GL_TRIANGLES, we simply flip the vertices. // For GL_TRIANGLE_FANs, we leave the first vertex at its place and flip the // remaining vertices. // For GL_TRIANGLE_STRIPs, things are more complicated. When the number of // vertices is uneven, we simply flip the vertices. When the number of // vertices is even, we have to add an additional vertex before we flip the // vertices. vector<TextVectorGlyph::PolygonOutline::TypeIndex>::const_iterator tIt; UInt32 indexBegin = 0, indexEnd; for (tIt = outline.types.begin(); tIt != outline.types.end(); ++tIt) { typesPtr->push_back(tIt->first); indexEnd = tIt->second; assert(indexEnd >= indexBegin); UInt32 len = indexEnd - indexBegin; UInt32 i = indexEnd; if (tIt->first == GL_TRIANGLE_FAN) { i = indexBegin; ++indexBegin; } if ((tIt->first == GL_TRIANGLE_STRIP) && ((len & 1) == 0)) { assert((indexEnd >= 2) && (indexEnd - 2 >= indexBegin)); i = indexEnd - 2; ++len; } if (i != indexEnd) { // the interleaved multi-index blocks have the layout // Position | Normal | TexCoord assert(i < outline.indices.size()); UInt32 index = outline.indices[i]; assert(backCoordOffset + index < posPtr->size()); indicesPtr->push_back(backCoordOffset + index); indicesPtr->push_back(1); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); i = indexEnd; } lensPtr->push_back(len); while (true) { if (i <= indexBegin) break; --i; // the interleaved multi-index blocks have the layout // Position | Normal | TexCoord assert(i < outline.indices.size()); UInt32 index = outline.indices[i]; assert(backCoordOffset + index < posPtr->size()); indicesPtr->push_back(backCoordOffset + index); indicesPtr->push_back(1); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); } indexBegin = indexEnd; } // Add the side faces to the geometry const TextVectorGlyph::Normals &normals = glyph.getNormals(level); // construct the multi index UInt32 start = 0, end, index = 0; vector<UInt32>::const_iterator iIt; vector<TextVectorGlyph::Orientation>::const_iterator oriIt = glyph.getContourOrientations().begin(); for (iIt = outline.contours.begin(); iIt != outline.contours.end(); ++iIt, ++oriIt) { assert(oriIt != glyph.getContourOrientations().end()); UInt32 contourCoordOffset, contourBackCoordOffset; if (*oriIt == TextVectorGlyph::CCW) { contourCoordOffset = coordOffset; contourBackCoordOffset = backCoordOffset; } else { contourCoordOffset = backCoordOffset; contourBackCoordOffset = coordOffset; } end = *iIt; // the side faces are stored as quads GLenum mode = GL_QUAD_STRIP; UInt32 len = 0; UInt32 coordIndex, backCoordIndex; UInt32 normalOffset, startNormalOffset = normalsPtr->size(); for (index = start; index < end; ++index) { normalOffset = normalsPtr->size() - 1; assert(index < normals.size()); if (normals[index].edgeAngle > creaseAngle) { // We have an edge with two normals, so we need to // add the vertices twice, but with different normals // - but only when this is not the start index if (index > start) { if ((mode == GL_QUAD_STRIP) && (len > 2)) { typesPtr->push_back(GL_QUAD_STRIP); assert(((len + 2) & 1) == 0); lensPtr->push_back(len + 2); len = 0; coordIndex = contourCoordOffset + index; backCoordIndex = contourBackCoordOffset + index; } else { mode = GL_QUADS; len += 2; coordIndex = contourBackCoordOffset + index; backCoordIndex = contourCoordOffset + index; } // back assert(backCoordIndex < posPtr->size()); indicesPtr->push_back(backCoordIndex); assert(normalOffset < normalsPtr->size()); indicesPtr->push_back(normalOffset); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); // front assert(coordIndex < posPtr->size()); indicesPtr->push_back(coordIndex); assert(normalOffset < normalsPtr->size()); indicesPtr->push_back(normalOffset); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); } const Vec2f &normal = normals[index].nextEdgeNormal; normalsPtr->push_back(Vec3f(normal.x(), normal.y(), 0.f)); } else { if (mode == GL_QUADS) { typesPtr->push_back(GL_QUADS); mode = GL_QUAD_STRIP; assert(len >= 6); assert(((len - 2) & 3) == 0); lensPtr->push_back(len - 2); len = 2; } const Vec2f &normal = normals[index].meanEdgeNormal; normalsPtr->push_back(Vec3f(normal.x(), normal.y(), 0.f)); } ++normalOffset; // back assert(contourBackCoordOffset + index < posPtr->size()); indicesPtr->push_back(contourBackCoordOffset + index); assert(normalOffset < normalsPtr->size()); indicesPtr->push_back(normalOffset); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); // front assert(contourCoordOffset + index < posPtr->size()); indicesPtr->push_back(contourCoordOffset + index); assert(normalOffset < normalsPtr->size()); indicesPtr->push_back(normalOffset); assert(texCoordOffset + index < texPtr->size()); indicesPtr->push_back(texCoordOffset + index); len += 2; } // We have to close the strip, so add the start vertices again if (normals[start].edgeAngle <= creaseAngle) normalOffset = startNormalOffset; if (mode == GL_QUAD_STRIP) { coordIndex = contourCoordOffset + start; backCoordIndex = contourBackCoordOffset + start; } else { coordIndex = contourBackCoordOffset + start; backCoordIndex = contourCoordOffset + start; } // back assert(backCoordIndex < posPtr->size()); indicesPtr->push_back(backCoordIndex); assert(normalOffset < normalsPtr->size()); indicesPtr->push_back(normalOffset); assert(texCoordOffset + start < texPtr->size()); indicesPtr->push_back(texCoordOffset + start); // front assert(coordIndex < posPtr->size()); indicesPtr->push_back(coordIndex); assert(normalOffset < normalsPtr->size()); indicesPtr->push_back(normalOffset); assert(texCoordOffset + start < texPtr->size()); indicesPtr->push_back(texCoordOffset + start); len += 2; // store the number of multi index blocks typesPtr->push_back(mode); assert((mode != GL_QUADS) || ((len & 3) == 0)); assert((mode != GL_QUAD_STRIP) || ((len & 1) == 0)); lensPtr->push_back(len); start = end; } } } endEditCP(typesPtr, GeoPTypesUI8::GeoPropDataFieldMask); endEditCP(indicesPtr, GeoIndicesUI32::GeoPropDataFieldMask); endEditCP(lensPtr, GeoPLengthsUI32::GeoPropDataFieldMask); endEditCP(texPtr, GeoTexCoords2f::GeoPropDataFieldMask); endEditCP(normalsPtr, GeoNormals3f::GeoPropDataFieldMask); endEditCP(posPtr, GeoPositions3f::GeoPropDataFieldMask); endEditCP(geoPtr); }

GeometryPtr osg::TextVectorFace::makeGeo (  const TextLayoutResult &  layoutResult, Real32  scale = 1.f, Real32  depth = 0.f, UInt32  level = 2, Real32  creaseAngle = Pi/4.f )

Creates a new text geometry. Parameters: layoutResult  The result of a layout operation. scale  The size of the glyphs. depth  The depth of the VectorGlyphs. If depth is 0.f no backside will be generated. level  The level of detail. Usually between 0 and 10. creaseAngle  The angle (in radians) which determines how faceted the glyphs should be lighted. If the angle enclosed by two vertex normals in a point exceeds the creaseAngle both of the two normals will be attached to the point. Otherwise their mean is used. Returns: A new text geometry. Definition at line 517 of file OSGTextVectorFace.cpp. References osg::GeometryBase::create(), and fillGeo(). Referenced by makeNode(). { GeometryPtr geo = Geometry::create(); fillGeo(geo, layoutResult, scale, depth, level, creaseAngle); return geo; }

NodePtr osg::TextVectorFace::makeNode (  const TextLayoutResult &  layoutResult, Real32  scale = 1.f, Real32  depth = 0.f, UInt32  level = 2, Real32  creaseAngle = Pi/4.f )

Creates a new node with a text geometry. Parameters: layoutResult  The result of a layout operation. scale  The size of the glyphs. depth  The depth of the VectorGlyphs. If depth is 0.f no backside will be generated. level  The level of detail. Usually between 0 and 10. creaseAngle  The angle (in radians) which determines how faceted the glyphs should be lighted. If the angle enclosed by two vertex normals in a point exceeds the creaseAngle both of the two normals will be attached to the point. Otherwise their mean is used. Returns: A new node containing a text geometry. Definition at line 530 of file OSGTextVectorFace.cpp. References osg::beginEditCP(), osg::Node::CoreFieldMask, osg::Node::create(), osg::endEditCP(), and makeGeo(). { GeometryPtr geo = makeGeo(layoutResult, scale, depth, level, creaseAngle); NodePtr node = Node::create(); beginEditCP(node, Node::CoreFieldMask); node->setCore(geo); endEditCP(node, Node::CoreFieldMask); return node; }

TextVectorFace * osg::TextVectorFace::create (  const std::string &  family, Style  style = STYLE_PLAIN )  [static]

Tries to create a vector face. Parameters: family  The font family of the face (Arial, Courier etc.) style  The style of the face (bold, italic etc.) Returns: The vector face object or 0 in case of an error. Definition at line 546 of file OSGTextVectorFace.cpp. References osg::TextFaceFactory::createVectorFace(), and osg::TextFaceFactory::the(). { return TextFaceFactory::the().createVectorFace(family, style); }

virtual std::auto_ptr<TextVectorGlyph> osg::TextVectorFace::createGlyph (  TextGlyph::Index  glyphIndex  )  [protected, pure virtual]

Creates a new Glyph object. This method has to be implemented by descendants of the VectorFace class. Parameters: glyphIndex  The index of the glyph. Returns: The glyph object or 0 when no glyph exists for the given glyph index. Referenced by getVectorGlyph().

const TextVectorFace& osg::TextVectorFace::operator= (  const TextVectorFace &   )  [private]

Copy operator (not implemented!)

const std::string osg::TextFace::getFamily (   )  const [inline, inherited]

Returns the actual font family of the face. Returns: The font family. Definition at line 43 of file OSGTextFace.inl. References osg::TextFace::_family. { return _family; }

TextFace::Style osg::TextFace::getStyle (   )  const [inline, inherited]

Returns the actual style of the face. Returns: The style. Definition at line 46 of file OSGTextFace.inl. References osg::TextFace::_style. { return _style; }

Real32 osg::TextFace::getHoriAscent (   )  const [inline, inherited]

Returns the ascent of the face for horizontal layout. The ascent is the distance from the baseline to the top of the face. Returns: The ascent for horizontal layout. Definition at line 49 of file OSGTextFace.inl. References osg::TextFace::_horiAscent. { return _horiAscent; }

Real32 osg::TextFace::getVertAscent (   )  const [inline, inherited]

Returns the ascent of the face for vertical layout. The ascent is the distance from the baseline to the left side of the face. This value is usually negative! Returns: The ascent for vertical layout. Definition at line 52 of file OSGTextFace.inl. References osg::TextFace::_vertAscent. { return _vertAscent; }

Real32 osg::TextFace::getHoriDescent (   )  const [inline, inherited]

Returns the descent of the face for horizontal layout. The descent is the distance from the baseline to the bottom of the face. This value is usually negative! Returns: The descent for horizontal layout. Definition at line 55 of file OSGTextFace.inl. References osg::TextFace::_horiDescent. { return _horiDescent; }

Real32 osg::TextFace::getVertDescent (   )  const [inline, inherited]

Returns the descent of the face for vertical layout. The descent is the distance from the baseline to the right side of the face. Returns: The descent for vertical layout. Definition at line 58 of file OSGTextFace.inl. References osg::TextFace::_vertDescent. { return _vertDescent; }

virtual void osg::TextFace::layout (  const std::string &  utf8Text, const TextLayoutParam &  param, TextLayoutResult &  result )  [virtual, inherited]

Lays out one line of text. Parameters: utf8Text  The UTF8 encoded text. param  Contains parameters that affect the layout process. result  Gets filled with the layout results. Reimplemented in osg::TextTXFFace.

virtual void osg::TextFace::layout (  const std::wstring &  text, const TextLayoutParam &  param, TextLayoutResult &  result )  [pure virtual, inherited]

Lays out one line of text. Parameters: text  The text. param  Contains parameters that affect the layout process. result  Gets filled with the layout results. Implemented in osg::TextTXFFace.

virtual void osg::TextFace::layout (  const std::vector< std::string > &  lines, const TextLayoutParam &  param, TextLayoutResult &  result )  [virtual, inherited]

Lays out multiple lines of text. Parameters: lines  The vector of UTF8 encoded lines. param  Contains parameters that affect the layout process. result  Gets filled with the layout results. Reimplemented in osg::TextTXFFace.

virtual void osg::TextFace::layout (  const std::vector< std::wstring > &  lines, const TextLayoutParam &  param, TextLayoutResult &  result )  [virtual, inherited]

Lays out multiple lines of text. Parameters: lines  The vector of text lines. param  Contains parameters that affect the layout process. result  Gets filled with the layout results. Reimplemented in osg::TextTXFFace.

void osg::TextFace::calculateBoundingBox (  const TextLayoutResult &  layoutResult, Vec2f &  lowerLeft, Vec2f &  upperRight )  [inherited]

Calculates the bounding box of a text after layout. Parameters: layoutResult  The results of the layout operation lowerLeft  After returning from the method, contains the lower left position of the bounding box upperRight  After returning from the method, contains the lower left position of the bounding box Definition at line 243 of file OSGTextFace.cpp. References osg::TextFace::getGlyph(), osg::TextGlyph::getHeight(), osg::TextLayoutResult::getNumGlyphs(), osg::TextGlyph::getWidth(), osg::TextLayoutResult::indices, osg::TextLayoutResult::positions, osg::VecStorage2< ValueTypeT >::setValues(), osg::VecStorage2< ValueTypeT >::x(), and osg::VecStorage2< ValueTypeT >::y(). Referenced by osg::TextPixmapFace::makeImage(). { // Initialize bounding box lowerLeft.setValues(FLT_MAX, FLT_MAX); upperRight.setValues(-FLT_MAX, -FLT_MAX); UInt32 i, numGlyphs = layoutResult.getNumGlyphs(); for (i = 0; i < numGlyphs; ++i) { const TextGlyph &glyph = getGlyph(layoutResult.indices[i]); Real32 width = glyph.getWidth(); Real32 height = glyph.getHeight(); // Don't handle invisible glyphs if ((width <= 0.f) || (height <= 0.f)) continue; // Calculate coodinates const Vec2f &pos = layoutResult.positions[i]; Real32 left = pos.x(); Real32 right = left + glyph.getWidth(); Real32 top = pos.y(); Real32 bottom = top - glyph.getHeight(); // Adjust bounding box if (lowerLeft[0] > left) lowerLeft[0] = left; if (upperRight[0] < right) upperRight[0] = right; if (upperRight[1] < top) upperRight[1] = top; if (lowerLeft[1] > bottom) lowerLeft[1] = bottom; } }

static void osg::TextFace::convertUTF8ToUnicode (  const std::string &  utf8Text, std::wstring &  text )  [static, inherited]

Converts a UTF8 encoded string to a unicode string. Parameters: utf8Text  The UTF8 encoded text string. text  A string that gets filled with the unicode version of the UTF8 encoded string. Referenced by osg::TextTXFParam::setCharacters().

void osg::TextFace::justifyLine (  const TextLayoutParam &  param, const std::vector< UInt32 > &  spaceIndices, Vec2f &  currPos, TextLayoutResult &  layoutResult )  const [protected, inherited]

Justifies one line of text. Parameters: param  The current layout parameters spaceIndices  The indices of space characters in the line currPos  The position on the base line behind the last character layoutResult  The glyph positions that get justified by this method.

void osg::TextFace::adjustLineOrigin (  const TextLayoutParam &  param, const Vec2f &  currPos, TextLayoutResult &  layoutResult )  const [protected, inherited]

Adjusts the positions of glyphs, depending on the alignment. Parameters: param  The current layout parameters currPos  The position on the base line behind the last character layoutResult  The glyph positions that gets adjusted by this method. Definition at line 402 of file OSGTextFace.cpp. References osg::TextFace::_horiAscent, osg::TextFace::_vertDescent, osg::TextLayoutParam::ALIGN_BEGIN, osg::TextLayoutParam::ALIGN_END, osg::TextLayoutParam::ALIGN_FIRST, osg::TextLayoutParam::ALIGN_MIDDLE, osg::TextLayoutParam::horizontal, osg::TextLayoutParam::leftToRight, osg::TextLayoutParam::majorAlignment, osg::TextLayoutParam::minorAlignment, osg::TextLayoutResult::positions, osg::TextLayoutParam::topToBottom, osg::VecStorage2< ValueTypeT >::x(), and osg::VecStorage2< ValueTypeT >::y(). { Vec2f offset; if (param.horizontal == true) { switch (param.minorAlignment) { default: case TextLayoutParam::ALIGN_FIRST: offset[1] = 0.f; break; case TextLayoutParam::ALIGN_BEGIN: offset[1] = -_horiAscent; break; case TextLayoutParam::ALIGN_MIDDLE: offset[1] = -(_horiAscent + _horiDescent) / 2.f; break; case TextLayoutParam::ALIGN_END: offset[1] = -_horiDescent; break; } if (param.leftToRight == true) { switch (param.majorAlignment) { default: case TextLayoutParam::ALIGN_FIRST: case TextLayoutParam::ALIGN_BEGIN: if (currPos.x() < 0)