326 lines
10 KiB
C++
326 lines
10 KiB
C++
/* -*-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_GLYPH
|
|
#define OSGTEXT_GLYPH 1
|
|
|
|
#include <string>
|
|
#include <istream>
|
|
|
|
#include <osg/Vec2>
|
|
#include <osg/Image>
|
|
#include <osg/Texture2D>
|
|
#include <osg/StateSet>
|
|
#include <osg/Geometry>
|
|
#include <osg/Geode>
|
|
|
|
#include <osgText/Export>
|
|
#include <osgText/KerningType>
|
|
#include <osgText/Style>
|
|
|
|
#include <OpenThreads/Mutex>
|
|
|
|
// GL_ALPHA is deprecated in GL3/GL4 core profile, use GL_RED and a shader in this case. See osgText example.
|
|
#if defined(OSG_GL3_AVAILABLE) && !defined(OSG_GL2_AVAILABLE) && !defined(OSG_GL1_AVAILABLE)
|
|
#define OSGTEXT_GLYPH_FORMAT GL_RED
|
|
#define OSGTEXT_GLYPH_INTERNALFORMAT GL_R8
|
|
#else
|
|
#define OSGTEXT_GLYPH_FORMAT GL_ALPHA
|
|
#define OSGTEXT_GLYPH_INTERNALFORMAT GL_ALPHA
|
|
#endif
|
|
|
|
namespace osgText {
|
|
|
|
class Font;
|
|
class Text;
|
|
class Glyph3D;
|
|
class GlyphGeometry;
|
|
class GlyphTexture;
|
|
|
|
class OSGTEXT_EXPORT Glyph : public osg::Image
|
|
{
|
|
public:
|
|
|
|
Glyph(Font* font, unsigned int glyphCode);
|
|
|
|
Font* getFont() { return _font; }
|
|
const Font* getFont() const { return _font; }
|
|
|
|
unsigned int getGlyphCode() const { return _glyphCode; }
|
|
|
|
void setFontResolution(const FontResolution& fontRes) { _fontResolution = fontRes; }
|
|
const FontResolution& getFontResolution() const { return _fontResolution; }
|
|
|
|
void setWidth(float width) { _width = width; }
|
|
float getWidth() const { return _width; }
|
|
|
|
void setHeight(float height) { _height = height; }
|
|
float getHeight() const { return _height; }
|
|
|
|
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;
|
|
|
|
protected:
|
|
|
|
virtual ~Glyph();
|
|
|
|
Font* _font;
|
|
unsigned int _glyphCode;
|
|
|
|
FontResolution _fontResolution;
|
|
|
|
float _width;
|
|
float _height;
|
|
|
|
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 GlyphGeometry : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
GlyphGeometry();
|
|
|
|
void setup(const Glyph3D* glyph, const Style* style);
|
|
|
|
bool match(const Style* style) const;
|
|
|
|
osg::Geode* getGeode() const { return _geode.get(); }
|
|
osg::Geometry* getGeometry() const { return _geometry.get(); }
|
|
|
|
/** Set the VertexArray of the glyph. */
|
|
void setVertexArray(osg::Vec3Array * va) { _vertices = va; }
|
|
/** Get the VertexArray of the glyph. */
|
|
osg::Vec3Array * getVertexArray() const { return _vertices.get(); }
|
|
|
|
/** Set the VertexArray of the glyph. */
|
|
void setNormalArray(osg::Vec3Array* na) { _normals = na; }
|
|
/** Get the NormalArray for the wall face. */
|
|
osg::Vec3Array* getNormalArray() const { return _normals.get(); }
|
|
|
|
/** 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 whether to use a mutex to ensure ref() and unref() are thread safe.*/
|
|
virtual void setThreadSafeRefUnref(bool threadSafe);
|
|
|
|
protected:
|
|
|
|
osg::ref_ptr<Style> _style;
|
|
osg::ref_ptr<osg::Geode> _geode;
|
|
osg::ref_ptr<osg::Geometry> _geometry;
|
|
osg::ref_ptr<osg::Vec3Array> _vertices;
|
|
osg::ref_ptr<osg::Vec3Array> _normals;
|
|
|
|
osg::Geometry::PrimitiveSetList _frontPrimitiveSetList;
|
|
osg::Geometry::PrimitiveSetList _wallPrimitiveSetList;
|
|
osg::Geometry::PrimitiveSetList _backPrimitiveSetList;
|
|
};
|
|
|
|
|
|
class OSGTEXT_EXPORT Glyph3D : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
Glyph3D(Font* font, unsigned int glyphCode);
|
|
|
|
Font* getFont() { return _font; }
|
|
const Font* getFont() const { return _font; }
|
|
|
|
unsigned int getGlyphCode() const { return _glyphCode; }
|
|
|
|
void setWidth(float width) { _width = width; }
|
|
float getWidth() const { return _width; }
|
|
|
|
void setHeight(float height) { _height = height; }
|
|
float getHeight() const { return _height; }
|
|
|
|
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(); }
|
|
const osg::Vec3Array* getRawVertexArray() const { return _rawVertexArray.get(); }
|
|
|
|
/** Get the PrimitiveSetList for the raw face which hasn't been tessellated. */
|
|
osg::Geometry::PrimitiveSetList & getRawFacePrimitiveSetList() { return _rawFacePrimitiveSetList; }
|
|
const osg::Geometry::PrimitiveSetList & getRawFacePrimitiveSetList() const { return _rawFacePrimitiveSetList; }
|
|
|
|
GlyphGeometry* getGlyphGeometry(const Style* style);
|
|
|
|
protected:
|
|
|
|
virtual ~Glyph3D() {}
|
|
|
|
Font* _font;
|
|
unsigned int _glyphCode;
|
|
|
|
float _width;
|
|
float _height;
|
|
|
|
osg::Vec2 _horizontalBearing;
|
|
float _horizontalAdvance;
|
|
|
|
osg::Vec2 _verticalBearing;
|
|
float _verticalAdvance;
|
|
|
|
osg::BoundingBox _bb;
|
|
// osg::Vec2 _advance;
|
|
|
|
|
|
osg::ref_ptr<osg::Vec3Array> _rawVertexArray;
|
|
osg::Geometry::PrimitiveSetList _rawFacePrimitiveSetList;
|
|
|
|
typedef std::list< osg::ref_ptr<GlyphGeometry> > GlyphGeometries;
|
|
GlyphGeometries _glyphGeometries;
|
|
|
|
};
|
|
|
|
|
|
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; }
|
|
|
|
void setGlyphInterval(int interval) { _interval = interval; }
|
|
int getGlyphInterval() const { return _interval; }
|
|
|
|
enum Features
|
|
{
|
|
GREYSCALE,
|
|
OUTLINE_GREYSCALE,
|
|
SIGNED_DISTANCE_FIELD,
|
|
ALL_FEATURES
|
|
};
|
|
|
|
void setGlyphTextureFeatures(Features features) { _glyphTextureFeatures = features; }
|
|
Features getGlyphTextureFeatures() const { return _glyphTextureFeatures; }
|
|
|
|
bool getSpaceForGlyph(Glyph* glyph, int& posX, int& posY);
|
|
|
|
void addGlyph(Glyph* glyph,int posX, int posY);
|
|
|
|
/** 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);
|
|
|
|
/** create an image that maps all the associated Glyph's onto a single image, that is equivalent to what will be downloaded to the texture.*/
|
|
osg::Image* createImage();
|
|
|
|
protected:
|
|
|
|
virtual ~GlyphTexture();
|
|
|
|
void copyGlyphImage(Glyph* glyph);
|
|
|
|
|
|
// parameter used to compute the size and position of empty space
|
|
// in the texture which could accommodate new glyphs.
|
|
int _margin;
|
|
float _marginRatio;
|
|
int _interval;
|
|
Features _glyphTextureFeatures;
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
#endif
|