FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added osgText::Paragraph which is a subclass from Geode which composes a

Browse Source 
list of text drawables as a paragraph block, handles breaking of text into
individual lines automatically.

Changed the osg::Node::setUserData so that the data type has to be an
osg::Referenced, and removes the dependancy on osg::MemoryAdapter.  I have
done this since it simplifies the OSG side of the interface and makes it
less like that the user might abuse the memory managment of the data. It
does however mean that user data will have by subclassed from Referenced,
and therefor may require users to have their own adapter to do this.
However, this little nuasance is worth the extra cleaness and robustness
afforded by going the osg::Referenced route.
This commit is contained in:
Robert Osfield
2001-11-09 15:06:01 +00:00
parent e35f5ec286
commit 7290f793f1
7 changed files with 43 additions and 525 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
include/osg/Node
View File

@@ -8,7 +8,6 @@
#include <osg/Object>
#include <osg/StateSet>
#include <osg/BoundingSphere>
#include <osg/MemoryAdapter>
#include <osg/NodeCallback>
#include <osg/ref_ptr>
@@ -120,27 +119,19 @@ class SG_EXPORT Node : public Object
/**
* Set user data. See MemoryAdapter documentation for details
* of how to specify memory management of _userData.
* Set user data, data must be subclased from Referenced to allow
* automatic memory handling. If you own data isn't directly
* subclassed from Referenced then create and adapter object
* which points to your own objects and handles the memory addressing.
*/
inline void setUserData(void* data,MemoryAdapter* ma=0L)
{
if (_userData && _memoryAdapter.valid()) _memoryAdapter->unref_data(_userData);
_userData = data;
_memoryAdapter = ma;
if (_userData && _memoryAdapter.valid()) _memoryAdapter->ref_data(_userData);
}
inline void setUserData(osg::Referenced* obj) { _userData = obj; }
/** Get user data.*/
inline void* getUserData() { return _userData; }
inline Referenced* getUserData() { return _userData.get(); }
/** Get const user data.*/
inline const void* getUserData() const { return _userData; }
inline const Referenced* getUserData() const { return _userData.get(); }
/** Get the memory adapter associated with _userData.*/
inline MemoryAdapter* getMemoryAdapter() { return _memoryAdapter.get(); }
/** Get the const memory adapter associated with _userData.*/
inline const MemoryAdapter* getMemoryAdapter() const { return _memoryAdapter.get(); }
typedef unsigned int NodeMask;
/** Set the node mask. Note, node mask is will be replaced by TraversalMask.*/
@@ -223,8 +214,7 @@ class SG_EXPORT Node : public Object
int _numChildrenWithCullingDisabled;
void setNumChildrenWithCullingDisabled(const int num);
void* _userData;
ref_ptr<MemoryAdapter> _memoryAdapter;
osg::ref_ptr<Referenced> _userData;
NodeMask _nodeMask;

221
include/osgText/Text
View File

@@ -23,214 +23,17 @@
#include <string>
#include <osg/GL>
#include <osg/Object>
#include <osg/Drawable>
#include <osg/Vec3>
#include <osg/Vec2>
// http://homepages.paradise.net.nz/henryj/code/
#include <osgText/Export>
class FTFont;
#include <osgText/Font>
namespace osgText {
///////////////////////////////////////////////////////////////////////////////
// Font - FontBaseClass
class OSGTEXT_EXPORT Font : public osg::Object
{
public:
Font();
virtual bool open(const std::string& font);
virtual bool create(int pointSize, const unsigned int res = 72 );
virtual bool create();
virtual void output(const char* text);
virtual bool isOk(void) const { return _init; }
virtual bool isCreated(void) const { return isOk() && _created; }
virtual float getWidth(const char* text) const;
virtual int getHeight() const;
virtual int getDescender() const;
virtual int getAscender() const;
int getPointSize(void) const { return _pointSize; }
const std::string& getFontName();
FTFont* getFont(void) { return _font; }
protected:
virtual ~Font();
virtual void clear();
virtual FTFont* createFontObj(void)=0;
bool init(const std::string& font);
bool _init;
bool _created;
FTFont* _font;
std::string _fontName;
int _pointSize;
int _res;
};
// Font
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// RasterFont
class OSGTEXT_EXPORT RasterFont:public Font
{
public:
RasterFont():Font(){;}
RasterFont(const std::string& font):Font(){;}
protected:
};
// RasterFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// VectorFont
class OSGTEXT_EXPORT VectorFont:public Font
{
public:
VectorFont():Font(){;}
VectorFont(const std::string& font):Font(){;}
protected:
double _precision;
};
// VectorFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// BitmapFont
class OSGTEXT_EXPORT BitmapFont:public RasterFont
{
public:
BitmapFont() {;}
BitmapFont(const std::string& font,
int point_size);
META_Object(BitmapFont);
protected:
virtual FTFont* createFontObj(void);
};
// BitmapFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PixmapFont
class OSGTEXT_EXPORT PixmapFont:public RasterFont
{
public:
PixmapFont() {;}
PixmapFont(const std::string& font,
int point_size);
META_Object(PixmapFont);
protected:
virtual FTFont* createFontObj(void);
};
// PixmapFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// TextureFont
class OSGTEXT_EXPORT TextureFont:public RasterFont
{
public:
TextureFont() {;}
TextureFont(const std::string& font,
int point_size);
META_Object(TextureFont);
protected:
virtual FTFont* createFontObj(void);
};
// PixmapFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// OutlineFont
class OSGTEXT_EXPORT OutlineFont:public VectorFont
{
public:
OutlineFont() {;}
OutlineFont(const std::string& font,
int point_size,
double precision);
META_Object(OutlineFont);
protected:
virtual FTFont* createFontObj(void);
};
// OutlineFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PolygonFont
class OSGTEXT_EXPORT PolygonFont:public VectorFont
{
public:
PolygonFont() {;}
PolygonFont(const std::string& font,
int point_size,
double precision);
META_Object(PolygonFont);
protected:
virtual FTFont* createFontObj(void);
};
// PolygonFont
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Text
class OSGTEXT_EXPORT Text:public osg::Drawable
class OSGTEXT_EXPORT Text : public osg::Drawable
{
public:
@@ -278,8 +81,8 @@ public:
void setBoundingBox(int mode);
int getBoundingBox() const { return _boundingBoxType; }
void setAlignement(int alignement);
int getAlignement() const { return _alignement; }
void setAlignment(int alignment);
int getAlignment() const { return _alignment; }
void setFont(Font* font);
Font* getFont() { return _font.get(); }
@@ -291,9 +94,9 @@ public:
virtual void drawImmediateMode(osg::State& state);
virtual void drawBoundingBox(void);
virtual void drawAlignement(void);
virtual void drawAlignment(void);
const osg::Vec3& getAlignementPos() const { return _alignementPos; };
const osg::Vec3& getAlignmentPos() const { return _alignmentPos; };
protected:
@@ -313,25 +116,25 @@ protected:
virtual void setDefaults(void);
virtual const bool computeBound(void) const;
virtual void calcBounds(osg::Vec3* min,osg::Vec3* max) const;
void initAlignement(osg::Vec3* min,osg::Vec3* max);
bool initAlignement(void);
void initAlignment(osg::Vec3* min,osg::Vec3* max);
bool initAlignment(void);
osg::ref_ptr<Font> _font;
bool _init;
bool _initAlignement;
bool _initAlignment;
std::string _text;
int _fontType;
int _alignement;
int _alignment;
int _drawMode;
int _boundingBoxType;
osg::Vec3 _pos;
osg::Vec3 _alignementPos;
osg::Vec3 _alignmentPos;
};
// Text
///////////////////////////////////////////////////////////////////////////////
};
#endif // _OSG_TEXT_H
#endif // OSGTEXT_TEXT