osg::Image* textImage()
{
#ifdef OSGAGG_USE_FREETYPE
unsigned char* buffer = new unsigned char[640 * 480 * 4];
agg::rendering_buffer renderingBuf( buffer, 640, 480, 640*4 );
agg::pixfmt_rgba32 pixelFormat( renderingBuf );
agg::renderer_base<agg::pixfmt_rgba32> renderer( pixelFormat );
renderer.clear( agg::rgba8(0, 0, 0, 0) );
agg::renderer_scanline_bin_solid< agg::renderer_base<agg::pixfmt_rgba32> > solidBin( renderer );
solidBin.color( agg::rgba8(255, 255, 255, 255) );
agg::font_engine_freetype_int32 font;
agg::font_cache_manager<agg::font_engine_freetype_int32> fontManager(font);
if ( font.load_font("arial.ttf", 0, agg::glyph_ren_native_mono) )
{
font.hinting( true );
font.height( 64 );
font.width( 64 );
font.flip_y( true );
agg::trans_affine transformation;
transformation *= agg::trans_affine_rotation( agg::deg2rad(-4.0) );
font.transform( transformation );
double x = 30.0, y = 450.0;
const char* text = "Hello World!";
const char* ptr = text;
while ( *ptr )
{
const agg::glyph_cache* glyph = fontManager.glyph( *ptr );
if ( glyph )
{
fontManager.add_kerning( &x, &y );
fontManager.init_embedded_adaptors( glyph, x, y );
switch ( glyph->data_type )
{
case agg::glyph_data_mono:
agg::render_scanlines(
fontManager.mono_adaptor(), fontManager.mono_scanline(), solidBin );
break;
default: break;
}
x += glyph->advance_x;
y += glyph->advance_y;
}
ptr++;
}
}
osg::ref_ptr<osg::Image> image = new osg::Image;
image->setImage( 640, 480, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, buffer, osg::Image::USE_NEW_DELETE );
return image.release();
#else
OSG_NOTICE << "[osgagg] FreeType support not built" << std::endl;
return new osg::Image;
#endif
}
void MSLayout::positionLabel(void)
{
if (label()->columns()>0)
{
int xpos,ypos;
int indent;
if (titleAlignment()&MSLeft)
{
indent=XTextWidth(fontManager()->fontStruct(label()->font()),"M",1);
xpos=highlightThickness()+shadowThickness()+margin()+indent;
}
else if (titleAlignment()&MSRight)
{
indent=XTextWidth(fontManager()->fontStruct(label()->font()),"M",1);
xpos=width()-(highlightThickness()+shadowThickness()+margin())-indent-label()->width();
}
else xpos=width()/2-label()->width()/2;
if (titleAlignment()&MSTop)
{
topShadowOffset(label()->height());
ypos=0;
}
else if (titleAlignment()&MSBottom)
{
topShadowOffset(0);
ypos=highlightThickness()+shadowThickness()+margin();
}
else
{
topShadowOffset(label()->height()/2);
ypos=0;
}
label()->moveTo(xpos,ypos);
if (mapped()==MSFalse) label()->map();
}
else
{
label()->unmap();
topShadowOffset(0);
}
}
int FontConverter::exec() {
/* Font converter dependencies */
PluginManager::Manager<Trade::AbstractImageConverter> imageConverterManager(Utility::Directory::join(args.value("plugin-dir"), "imageconverters/"));
/* Load font */
PluginManager::Manager<Text::AbstractFont> fontManager(Utility::Directory::join(args.value("plugin-dir"), "fonts/"));
if(!(fontManager.load(args.value("font")) & PluginManager::LoadState::Loaded))
std::exit(1);
std::unique_ptr<Text::AbstractFont> font = fontManager.instance(args.value("font"));
/* Load font converter */
PluginManager::Manager<Text::AbstractFontConverter> converterManager(Utility::Directory::join(args.value("plugin-dir"), "fontconverters/"));
if(!(converterManager.load(args.value("converter")) & PluginManager::LoadState::Loaded))
std::exit(1);
std::unique_ptr<Text::AbstractFontConverter> converter = converterManager.instance(args.value("converter"));
/* Open font */
if(!font->openFile(args.value("input"), args.value<Float>("font-size"))) {
Error() << "Cannot open font" << args.value("input");
std::exit(1);
}
/* Create distance field glyph cache if radius is specified */
std::unique_ptr<Text::GlyphCache> cache;
if(!args.value<Vector2i>("output-size").isZero()) {
Debug() << "Populating distance field glyph cache...";
cache.reset(new Text::DistanceFieldGlyphCache(
args.value<Vector2i>("atlas-size"),
args.value<Vector2i>("output-size"),
args.value<Int>("radius")));
/* Otherwise use normal cache */
} else {
Debug() << "Zero-size distance field output specified, populating normal glyph cache...";
cache.reset(new Text::GlyphCache(args.value<Vector2i>("atlas-size")));
}
/* Fill the cache */
font->fillGlyphCache(*cache, args.value("characters"));
Debug() << "Converting font...";
/* Convert the font */
if(!converter->exportFontToFile(*font, *cache, args.value("output"), args.value("characters"))) {
Error() << "Cannot export font to" << args.value("output");
std::exit(1);
}
Debug() << "Done.";
return 0;
}
int MSLayout::idealWidth(void) const
{
int offset=highlightThickness()+shadowThickness()+margin();
int w=(vectorWidth()+2*innerWidth()+(columns()-1)*columnSpacing()+2*offset);
if (label()->mapped()==MSTrue)
{
int lw=label()->width()+2*offset;
if ((titleAlignment()&MSLeft)||(titleAlignment()&MSRight))
lw+=(2*XTextWidth(fontManager()->fontStruct(label()->font()),"M",1));
return (w>lw)?w:lw;
}
else return w;
}
View *CreateView(client::IRenderer *renderer, client::IAudioDevice *dev) override {
Handle<client::FontManager> fontManager(new client::FontManager(renderer),
false);
view.Set(new StartupScreen(renderer, dev, helper, fontManager), true);
return view;
}
