void axClientQuit() {
// g_shaderManager->saveShaderCache();
SafeDelete(g_soundSystem);
g_inputSystem->finalize();
SafeDelete(g_inputSystem);
g_defaultFont.clear();
g_consoleFont.clear();
g_miniFont.clear();
#ifdef AX_CONFIG_OPTION_USE_SPEEDTREE_40
g_renderSystem->removeEntityManager(g_treeManager);
SafeDelete(g_treeManager);
#endif // AX_CONFIG_OPTION_USE_SPEEDTREE_40
g_fontFactory->finalize();
g_assetManager->removeType(Asset::kFont);
SafeDelete(g_fontFactory);
g_assetManager->removeType(RenderMaterial::AssetType);
SafeDelete(gMaterialFactory);
g_renderSystem->finalize();
SafeDelete(g_renderSystem);
g_renderQueue->finalize();
SafeDelete(g_renderQueue);
}
unsigned TextBox::GetTextBoxHeight() const
{
FontPtr pFont = Renderer::GetInstance().GetFont(mTextSize);
float height = pFont->GetHeight();
pFont->SetBackToOrigHeight();
return Round(height * mNumTextLines) + 16;
}
FontManager::FontPtr FontManager::Load(const std::string& locator){
std::string file;
int size;
std::string::size_type plast = locator.find_last_not_of(";");
std::string::size_type pfirst = locator.find_first_of(";");
std::string tmp;
if((plast == std::string::npos) || (pfirst == std::string::npos)){
file = locator;
size = DEFAULT_FONT_SIZE;
}else{
file = locator.substr(0, plast - 2);
tmp = locator.substr(pfirst + 1);
std::istringstream iss(tmp);
iss >> size;
}
file = "content/fonts/" + file;
FontPtr font = FontPtr(new sf::Font());
if( !font->LoadFromFile(file, size))
return FontPtr();
return font;
}
//! [font_translate]
void FontTranslator::translate(ScriptCompiler* compiler, const AbstractNodePtr& node)
{
ObjectAbstractNode* obj = static_cast<ObjectAbstractNode*>(node.get());
// Must have a name - unless we are in legacy mode. Then the class is the name.
if (obj->name.empty() && obj->cls == "font")
{
compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line,
"font must be given a name");
return;
}
String& name = obj->cls == "font" ? obj->name : obj->cls;
FontPtr font = FontManager::getSingleton().create(name, compiler->getResourceGroup());
font->_notifyOrigin(obj->file);
for (auto& c : obj->children)
{
if (c->type == ANT_PROPERTY)
{
parseAttribute(compiler, font, static_cast<PropertyAbstractNode*>(c.get()));
}
}
}
float
Menu::get_width() const
{
/* The width of the menu has to be more than the width of the text
with the most characters */
float menu_width = 0;
for(unsigned int i = 0; i < items.size(); ++i)
{
FontPtr font = Resources::Resources::normal_font;
if(items[i]->kind == MN_LABEL)
font = Resources::big_font;
float w = font->get_text_width(items[i]->text) +
Resources::big_font->get_text_width(items[i]->input) + 16;
if(items[i]->kind == MN_TOGGLE)
w += 32;
if (items[i]->kind == MN_STRINGSELECT)
w += font->get_text_width(items[i]->list[items[i]->selected]) + 32;
if(w > menu_width)
menu_width = w;
}
return menu_width + 24;
}
ObjectPtr<Object> Font::restoreObject(SaveGame *state) {
const char *fname = state->readCharString();
FontPtr font = g_resourceloader->getFont(fname);
delete[] fname;
ObjectPtr<Object> ptr = font.object();
return ptr;
}
void TextBox::CalcTextWidth()
{
// analyze the text length
FontPtr pFont = Renderer::GetInstance().GetFont(mTextSize);
unsigned width = mSize.x;
float textWidth;
mMultiLineText = pFont->InsertLineFeed((const char*)mTextw.c_str(), mTextw.size() * 2, width, &textWidth, &mNumTextLines);
mTextWidth = (unsigned)Round(textWidth);
pFont->SetBackToOrigHeight();
mUIObject->SetText(mMultiLineText.c_str());
}
IECore::ConstObjectPtr Text::computeSource( const Context *context ) const
{
std::string fontFileName = fontPlug()->getValue();
std::string text = textPlug()->getValue();
if( !text.size() || !fontFileName.size() )
{
return outPlug()->objectPlug()->defaultValue();
}
FontPtr font = Detail::fontCache()->get( fontFileName );
return font->mesh( text );
}
WONButtonPtr WinSkin::CalcCheckButton(const char *theBitmapName, WONButton *orig)
{
WONButtonPtr aCheckbox = new WONButton;
aCheckbox->SetPushOffsets(0,0);
aCheckbox->SetHasCheck(true);
aCheckbox->SetScaleImage(false);
RawImagePtr aButtonMasterImage = GetRawImage("Buttons",theBitmapName);
int aNumPictures = GetIntParam("Buttons","EnhancedMode")?5:4;
if(aButtonMasterImage.get()==NULL)
return orig;
int aWidth = aButtonMasterImage->GetWidth()/aNumPictures;
aCheckbox->SetTextPadding(aWidth + 4,2,2,2);
int aColor = GetColor("Buttons","NormalColour");
FontPtr aFont = GetFont("Buttons","NormalFont");
if(aFont.get()==NULL)
aFont = mWindow->GetWindowManager()->GetNamedFont("MSButton");
if(aColor==-1)
aColor = 0;
CropImageFilterPtr aCrop = new CropImageFilter;
aCrop->SetSize(aWidth,aButtonMasterImage->GetHeight());
for(int i=0; i<4; i++)
{
aCrop->SetPos(i*aWidth,0);
RawImagePtr aRawImage = aCrop->Filter(aButtonMasterImage);
NativeImagePtr aNativeImage = aRawImage->GetNative(mWindow->GetDisplayContext());
bool checked = i&1?true:false;
int anIndex = i>=2?2:0;
aCheckbox->SetButtonState(anIndex,aNativeImage,aColor,aFont,checked);
if(anIndex==0)
{
RawImagePtr aRawImage2 = (RawImage*)aRawImage->Duplicate().get();
TintImageFilterPtr aTint = new TintImageFilter(100,100,150);
aTint->Filter(aRawImage);
aNativeImage = aRawImage->GetNative(mWindow->GetDisplayContext());
aCheckbox->SetButtonState(3,aNativeImage,aColor,aFont,checked);
aTint = new TintImageFilter(100,150,100);
aTint->Filter(aRawImage2);
aNativeImage = aRawImage2->GetNative(mWindow->GetDisplayContext());
aCheckbox->SetButtonState(1,aNativeImage,aColor,aFont,checked);
}
}
return aCheckbox;
}
void CategorizedList::Category::layoutChildren()
{
FontPtr font = parent.GetFont();
float pos = font ? font->getLineSpacing() : 0.f;
std::vector<window_ptr>::iterator i = children.begin();
std::vector<window_ptr>::iterator end = children.end();
while(i != end)
{
window_ptr child = *i;
child->setPosition(point(area.m_left, area.m_top + pos));
pos += child->getArea().getHeight();
++i;
}
}
FontPtr FontManager::load(std::string path)
{
if(isLoaded(path))
{
throw runtime_error("Font '" + path + "' already loaded");
}
FontPtr New = make_shared<Font>();
if(!New->loadFromFile(path))
{
throw runtime_error("Cannot load font " + path);
}
return New;
}
void BadUserItem::Paint(Graphics &g, ListArea *theListArea)
{
int aColor = theListArea->GetTextColor();
if(mSelected)
aColor = theListArea->GetSelColor().GetForegroundColor(g,aColor);
int aPaintCol = 0;
bool drawSelection = mSelected;
if(!mIsSimple)
{
aPaintCol = ((MultiListArea*)theListArea)->GetColumnPaintContext();
if(aPaintCol!=-1)
drawSelection = false;
}
if(drawSelection)
{
g.SetColor(theListArea->GetSelColor().GetBackgroundColor(g));
g.FillRect(0,0,theListArea->GetPaintColumnWidth(),mFont->GetHeight());
if(!mIsSimple)
return;
}
if(aPaintCol<0 || aPaintCol>5)
return;
g.SetColor(aColor);
g.SetFont(mFont);
g.DrawString(mColStr[aPaintCol],0,0);
}
void MarkupBase::render(const Rect& finalRect, const Rect& finalClip)
{
size_t len = m_text.length();
std::vector<PTextLine>::const_iterator i = m_textlines.begin();
std::vector<PTextLine>::const_iterator end = m_textlines.end();
while(i != end)
{
const TextLine* line = (*i).get();
size_t offset = line->start;
Rect rl(line->area);
std::vector<PText>::const_iterator c = line->children.begin();
std::vector<PText>::const_iterator stop = line->children.end();
while(c != stop)
{
const Text* chunk = (*c).get();
if(chunk->len > 0 && chunk->len <= len)
{
FontPtr f = chunk->font;
Color col = chunk->selected ? chunk->selcol : chunk->col;
std::string buf = m_text.substr(chunk->start + offset, chunk->len);
Rect rc(chunk->area);
rc.offset(rl.getPosition());
rc.offset(finalRect.getPosition());
f->drawText(buf, rc, 1.0f, finalClip, LeftAligned, col, 1.f, 1.f);
}
++c;
}
++i;
}
Renderer& r = m_system.getRenderer();
std::vector<PImg>::const_iterator cimg = m_images.begin();
std::vector<PImg>::const_iterator cimgend = m_images.end();
while(cimg != cimgend)
{
const Img* img = (*cimg).get();
Rect rc(img->area);
rc.offset(finalRect.getPosition());
if (img->img)
{
r.draw(*img->img, rc, 1.f, finalClip, m_backColor, Stretch, Stretch);
}
++cimg;
}
}
std::vector<std::unique_ptr<InfoBoxLine> >
InfoBoxLine::split(const std::string& text, float width)
{
std::vector<std::unique_ptr<InfoBoxLine> > lines;
std::string::size_type i = 0;
std::string::size_type l;
char format_char = '#';
while(i < text.size()) {
// take care of empty lines - represent them as blank lines of normal text
if (text[i] == '\n') {
lines.emplace_back(new InfoBoxLine('\t', ""));
i++;
continue;
}
// extract the format_char
format_char = text[i];
i++;
if (i >= text.size()) break;
// extract one line
l = text.find("\n", i);
if (l == std::string::npos) l=text.size();
std::string s = text.substr(i, l-i);
i = l+1;
// if we are dealing with an image, just store the line
if (format_char == '!') {
lines.emplace_back(new InfoBoxLine(format_char, s));
continue;
}
// append wrapped parts of line into list
std::string overflow;
do {
FontPtr font = get_font_by_format_char(format_char);
std::string s2 = s;
if (font) s2 = font->wrap_to_width(s2, width, &overflow);
lines.emplace_back(new InfoBoxLine(format_char, s2));
s = overflow;
} while (s.length() > 0);
}
return lines;
}
//---------------------------------------------------------------------
void FontManager::parseScript(DataStreamPtr& stream, const String& groupName)
{
String line;
FontPtr pFont;
while( !stream->eof() )
{
line = stream->getLine();
// Ignore blanks & comments
if( !line.length() || line.substr( 0, 2 ) == "//" )
{
continue;
}
else
{
if (pFont.isNull())
{
// No current font
// So first valid data should be font name
if (StringUtil::startsWith(line, "font "))
{
// chop off the 'particle_system ' needed by new compilers
line = line.substr(5);
}
pFont = create(line, groupName);
pFont->_notifyOrigin(stream->getName());
// Skip to and over next {
stream->skipLine("{");
}
else
{
// Already in font
if (line == "}")
{
// Finished
pFont.setNull();
// NB font isn't loaded until required
}
else
{
parseAttribute(line, pFont);
}
}
}
}
}
TextSprite::TextSprite(MaterialPtr material, const std::string &text, FontPtr font, PropertiesPtr properties)
: Sprite(), _text(text), _font(font)
{
// Create geometry
createGeometry();
// Add atlas texture to the material
material->setTexture(bRenderer::DEFAULT_SHADER_UNIFORM_CHARACTER_MAP(), font->getAtlas());
setMaterial(material);
setProperties(properties);
}
void OgreText::calculateTextPixelSize(DisplayString text, FontPtr mpFont, Real mCharHeight, Real& width, Real& height)
{
Real vpWidth, vpHeight;
vpWidth = (Real) (OverlayManager::getSingleton().getViewportWidth());
vpHeight = (Real) (OverlayManager::getSingleton().getViewportHeight());
//ROS_ERROR("[viewport] w: %f h: %f",vpWidth,vpHeight);
Real mViewportAspectCoef = vpHeight/vpWidth;
height = mCharHeight;
width = 0;
Real len = 0.0f;
for(DisplayString::iterator i = text.begin();i!=text.end();++i)
{
Font::CodePoint character = OGRE_DEREF_DISPLAYSTRING_ITERATOR(i);
if (character == UNICODE_CR
|| character == UNICODE_NEL
|| character == UNICODE_LF)
{
height += mCharHeight;
if(len > width)
width = len;
len = 0;
}
else if (character == UNICODE_SPACE) // space
{
len += mpFont->getGlyphAspectRatio(UNICODE_ZERO) * mCharHeight;// * 2.0 * mViewportAspectCoef;
}
else
{
len += mpFont->getGlyphAspectRatio(character) * mCharHeight;// * 2.0 * mViewportAspectCoef;
}
}
if(len > width)
width = len;
}
TextSprite::TextSprite(ObjectManager *o, const std::string &name, vmml::Vector3f color, const std::string &text, FontPtr font, PropertiesPtr properties)
: Sprite(), _text(text), _font(font)
{
// Create geometry
createGeometry();
// Create shader and material
ShaderPtr shader = o->generateShader(name, { 0, false, true, false, false, true, false, false, false, false, false, false, true });
MaterialPtr material = o->createMaterial(name, shader);
// Add atlas texture to the material
material->setTexture(bRenderer::DEFAULT_SHADER_UNIFORM_CHARACTER_MAP(), font->getAtlas());
// Pass color to material (don't pass texture, has to be treated separately to bind right tex unit)
material->setVector(bRenderer::WAVEFRONT_MATERIAL_DIFFUSE_COLOR(), color);
setMaterial(material);
setProperties(properties);
}
void
DrawingContext::draw_text(FontPtr font, const std::string& text,
const Vector& position, FontAlignment alignment, int layer, Color color)
{
DrawingRequest* request = new(obst) DrawingRequest();
request->target = target;
request->type = TEXT;
request->pos = transform.apply(position);
request->layer = layer;
request->drawing_effect = transform.drawing_effect;
request->alpha = transform.alpha;
request->color = color;
TextRequest* textrequest = new(obst) TextRequest();
textrequest->font = font.get();
textrequest->text = text;
textrequest->alignment = alignment;
request->request_data = textrequest;
requests->push_back(request);
}
void get_logfont(FontPtr font, LOGFONT * lf) {
D3DXFONT_DESC fd;
HRESULT hr = font->GetDesc(&fd);
if (FAILED(hr)) DX_EXCEPT("Failed call to ID3DXFont::GetDesc(). ", hr);
LOGFONT f = {
fd.Height,
fd.Width,
0,
0,
fd.Weight,
static_cast<BYTE>(fd.Italic),
0,
0,
fd.CharSet,
fd.OutputPrecision,
CLIP_DEFAULT_PRECIS,
QUALITY, //fd.Quality,
fd.PitchAndFamily,
};
_tcscpy(f.lfFaceName, fd.FaceName);
*lf = f;
}
//---------------------------------------------------------------------
void FontManager::parseAttribute(const String& line, FontPtr& pFont)
{
vector<String>::type params = StringUtil::split(line);
String& attrib = params[0];
StringUtil::toLowerCase(attrib);
if (attrib == "type")
{
// Check params
if (params.size() != 2)
{
logBadAttrib(line, pFont);
return;
}
// Set
StringUtil::toLowerCase(params[1]);
if (params[1] == "truetype")
{
pFont->setType(FT_TRUETYPE);
}
else
{
pFont->setType(FT_IMAGE);
}
}
else if (attrib == "source")
{
// Check params
if (params.size() != 2)
{
logBadAttrib(line, pFont);
return;
}
// Set
pFont->setSource(params[1]);
}
else if (attrib == "glyph")
{
// Check params
if (params.size() != 6)
{
logBadAttrib(line, pFont);
return;
}
// Set
// Support numeric and character glyph specification
Font::CodePoint cp;
if (params[1].at(0) == 'u' && params[1].size() > 1)
{
// Unicode glyph spec
String trimmed = params[1].substr(1);
cp = StringConverter::parseUnsignedInt(trimmed);
}
else
{
// Direct character
cp = params[1].at(0);
}
pFont->setGlyphTexCoords(
cp,
StringConverter::parseReal(params[2]),
StringConverter::parseReal(params[3]),
StringConverter::parseReal(params[4]),
StringConverter::parseReal(params[5]), 1.0 ); // assume image is square
}
else if (attrib == "size")
{
// Check params
if (params.size() != 2)
{
logBadAttrib(line, pFont);
return;
}
// Set
pFont->setTrueTypeSize(
StringConverter::parseReal(params[1]));
}
else if (attrib == "character_spacer")
{
// Check params
if (params.size() != 2)
{
logBadAttrib(line, pFont);
return;
}
// Set
pFont->setCharacterSpacer(
StringConverter::parseUnsignedInt(params[1]));
}
else if (attrib == "resolution")
{
// Check params
if (params.size() != 2)
{
logBadAttrib(line, pFont);
return;
}
// Set
pFont->setTrueTypeResolution(
(uint)StringConverter::parseReal(params[1]) );
}
else if (attrib == "antialias_colour")
{
// Check params
if (params.size() != 2)
{
logBadAttrib(line, pFont);
return;
}
// Set
pFont->setAntialiasColour(StringConverter::parseBool(params[1]));
}
else if (attrib == "code_points")
{
for (size_t c = 1; c < params.size(); ++c)
{
String& item = params[c];
StringVector itemVec = StringUtil::split(item, "-");
if (itemVec.size() == 2)
{
pFont->addCodePointRange(Font::CodePointRange(
StringConverter::parseUnsignedInt(itemVec[0]),
StringConverter::parseUnsignedInt(itemVec[1])));
}
}
}
}
void BadUserItem::CalcDimensions(ListArea *theListArea)
{
mFont = theListArea->GetFont();
mHeight = mFont->GetHeight();
}
WONButtonPtr WinSkin::CalcButton(const char *theSection, const char *theBitmapName, WONButton *orig)
{
RawImagePtr aButtonMasterImage = GetRawImage(theSection,theBitmapName);
if(aButtonMasterImage.get()==NULL)
return orig;
bool isTab = false;
bool isHeader = false;
if(stricmp(theSection,"HeaderBar")==0)
{
isHeader = true;
mSkin->mListCtrl->SetHeaderHeight(aButtonMasterImage->GetHeight());
}
else if(stricmp(theSection,"Tabs")==0)
{
mSkin->mTabCtrl->SetTabBarHeight(aButtonMasterImage->GetHeight());
isTab = true;
}
WONButtonPtr aButton;
if(isHeader)
aButton = new WONHeaderButton;
else
aButton = new WONButton;
int leftWidth = GetIntParam(theSection,"LeftWidth");
int topHeight = GetIntParam(theSection,"TopHeight");
int rightWidth = GetIntParam(theSection,"RightWidth");
int bottomHeight = GetIntParam(theSection,"BottomHeight");
int tile = GetIntParam(theSection,"Tile");
bool mouseOver = GetIntParam(theSection,"MouseOver")?true:false;
aButton->SetButtonFlags(ButtonFlag_InvalidateOnMouseOver,mouseOver);
// aButton->SetTextPaddingAtLeast(leftWidth+2,topHeight+2,rightWidth+2,bottomHeight+2);
int aNumFrames = GetIntParam(theSection,"FrameCount");
if(aNumFrames<5)
aNumFrames = 5;
int aWidth = aButtonMasterImage->GetWidth()/aNumFrames;
const char *colornames[] = { "NormalColour", "PressedColour", "DisabledColour", "FocusColour", "DefaultColour" };
const char *fontnames[] = { "NormalFont", "PressedFont", "DisabledFont", "FocusFont", "DefaultFont" };
CropImageFilterPtr aCrop = new CropImageFilter;
aCrop->SetSize(aWidth,aButtonMasterImage->GetHeight());
for(int i=0; i<5; i++)
{
StretchImagePtr aStretchImage = NULL;
if(i<5)
{
aCrop->SetPos(i*aWidth,0);
RawImagePtr aRawImage = aCrop->Filter(aButtonMasterImage);
aStretchImage = new StretchImage(aRawImage,leftWidth,topHeight,rightWidth,bottomHeight);
switch(tile)
{
case 0: aStretchImage->SetTile(false,false); break;
case 1: aStretchImage->SetTile(true,true); break;
case 2: aStretchImage->SetTile(true,false); break;
case 3: aStretchImage->SetTile(false,true); break;
}
}
int aColor = GetColor(theSection,colornames[i]);
FontPtr aFont = GetFont(theSection,fontnames[i]);
if(i==0)
{
if(aFont.get()==NULL)
aFont = mWindow->GetWindowManager()->GetNamedFont("MSButton");
if(aColor==-1)
aColor = 0;
}
if(i==1 && isTab)
{
aButton->SetHasCheck(true);
aButton->SetButtonState(0,aStretchImage,aColor,aFont,true);
}
else
aButton->SetButtonState(i,aStretchImage,aColor,aFont);
}
aButton->SetTransparent(aButtonMasterImage->HasTransparency());
return aButton;
}
void render(const text::utf32_string& inText, const vector<Range>& lines, const FontPtr& font, const RenderedTextPtr& target, bool characterMetrics, int align)
{
// these arrays will receive the character geometry in space, relative to a 0,0 baseline
// and the corresponding pixel coordinates of the subtexture within the font texture atlas
// used to draw the character
vector<math::Vec2> lineBounds;
vector<math::Rect> characterRects;
vector<math::Rect> pixelCoordRects;
// size calculation
Vec2 pmin, pmax;
uint32_t addIndex=0; // we iterate over all chracters, but not all of them might be drawable
// so we need a separate index for the actual insertion of a character into the mesh
uint32_t previousGlyphIndex = 0;
float xoffset = 0;
float yoffset = std::max((float)lines.size()-1, 0.0f)*floorf(font->lineHeight);
if(characterMetrics) {target->resetCharacterMetrics(); }
for(vector<Range>::const_iterator pos=lines.begin(); pos!=lines.end(); ++pos)
{
if(characterMetrics) {target->pushEmptyCharacterMetricLine();}
if(pos->begin != pos->end) // skip empty lines
{
Vec2 bounds(addIndex,addIndex);
for(uint32_t i=pos->begin; i<pos->end; ++i)
{
text::utf32_char c = inText[i];
xoffset+=font->kerningOffset(previousGlyphIndex, c);
GlyphPtr glyph = font->glyph(c);
if (!glyph) continue;
if (glyph->drawable)
{
addGlyph(characterRects, pixelCoordRects, glyph, xoffset, yoffset, pmin, pmax);
if(characterMetrics) {target->pushCharacterRect(characterRects[addIndex]);}
addIndex++;
}
else
{
// push dummy rect for metrics if char was not drawable
if(characterMetrics) {target->pushCharacterRect(Rect(xoffset,yoffset,glyph->advance,font->lineHeight));}
}
xoffset+=glyph->advance;
}
if (align != 0 && addIndex > 0) {
bounds.max = addIndex-1;
lineBounds.push_back(bounds);
}
}
xoffset = 0;
yoffset -= floorf(font->lineHeight);
previousGlyphIndex = 0;
}
// horizontal align center/right
if (align != 0) {
float maxWidth = (pmax.x-pmin.x)+1;
for (vector<math::Vec2>::iterator b = lineBounds.begin(); b != lineBounds.end(); ++b) {
int offset = (maxWidth - (characterRects[b->max].x+characterRects[b->max].width-characterRects[b->min].x));
if (offset > 0) {
if (align == 1) {
offset /= 2.0f;
}
for (int c = b->min; c <= b->max; ++c) {
characterRects[c].x += offset;
}
}
}
}
target->init(characterRects, font->atlas, pixelCoordRects, false);
target->min = pmin;
target->max = pmax;
target->size.width = (pmax.x-pmin.x)+1;
target->size.height = (pmax.y-pmin.y)+1;
target->material->blendPremultiplied();
target->numLines = lines.size();
}
void
Canvas::draw_text(const FontPtr& font, const std::string& text,
const Vector& pos, FontAlignment alignment, int layer, const Color& color)
{
font->draw_text(*this, text, pos, alignment, layer, color);
}
Dimension get_char_dim(FontPtr font) {
TEXTMETRIC tm;
if (!font->GetTextMetrics(&tm)) MISC_EXCEPT("Failed call to ID3DXFont::GetTextMetrics(). ");
return Dimension(tm.tmAveCharWidth, tm.tmHeight);
}
//---------------------------------------------------------------------
void FontManager::logBadAttrib(const String& line, FontPtr& pFont)
{
LogManager::getSingleton().logMessage("Bad attribute line: " + line +
" in font " + pFont->getName(), LML_CRITICAL);
}
namespace Axon {
AX_DECLARE_MODULE(axopengl);
AX_DECLARE_MODULE(axdirect3d9);
using namespace Axon::Render;
// using namespace Axon::PARTICLESYSTEM;
// console variable
#define AX_CVARDECL(name, defaultstring, flags) \
Cvar* name;
#include <axclient/cvardecls.h>
#undef AX_CVARDECL
// statistic
#define AX_STATDECL(name, desc, autoreset) int name;
#include "axclient/statdecls.h"
#undef AX_STATDECL
// public object
Render::System* g_renderSystem;
Render::Queue* g_renderQueue;
Render::Queue* g_queues[2];
Render::ShaderMacro g_shaderMacro;
Render::Uniforms g_uniforms;
Render::IDriver* g_renderDriver;
Render::TargetManager* g_targetManager;
Render::ShaderManager* g_shaderManager;
Render::PrimitiveManager* g_primitiveManager;
Render::QueryManager* g_queryManager;
InputSystem* g_inputSystem;
SoundSystem* g_soundSystem;
FontPtr g_defaultFont;
FontPtr g_consoleFont;
FontPtr g_miniFont;
// only visible in this module
FontFactory* g_fontFactory;
MaterialFactory* gMaterialFactory;
#ifdef AX_CONFIG_OPTION_USE_SPEEDTREE_40
TreeManager* g_treeManager;
#endif // AX_CONFIG_OPTION_USE_SPEEDTREE_40
// xinput
// Xinput* gXinput;
void axClientInit() {
// init cvar
#define AX_CVARDECL(name, defaultstring, flags) \
name = g_cvarSystem->createCvar(#name, defaultstring, flags);
#include <axclient/cvardecls.h>
#undef AX_CVARDECL
// init statistic
#define AX_STATDECL(name, desc, autoreset) \
name = g_statistic->getIndex(Statistic::RenderDrvGroup, desc, autoreset);
#include "axclient/statdecls.h"
#undef AX_STATDECL
#if 1 // _LIB
AX_REGISTER_MODULE(axopengl);
AX_REGISTER_MODULE(axdirect3d9);
#endif
g_renderSystem = new Render::System;
g_renderSystem->initialize();
gMaterialFactory = new MaterialFactory;
g_assetManager->registerType(RenderMaterial::AssetType, gMaterialFactory);
g_fontFactory = new FontFactory;
g_assetManager->registerType(Asset::kFont, g_fontFactory);
g_fontFactory->initialize();
g_defaultFont = FindAsset_<Font>("fonts/default", Font::makeSize(14,14));
g_consoleFont = FindAsset_<Font>("fonts/console", Font::makeSize(14,14));
g_miniFont = FindAsset_<Font>("fonts/console", Font::makeSize(11,11));
g_renderDriver->postInit();
#ifdef AX_CONFIG_OPTION_USE_SPEEDTREE_40
g_treeManager = new TreeManager();
g_renderSystem->addEntityManager(g_treeManager);
#endif
g_inputSystem = new InputSystem();
g_inputSystem->initialize();
g_soundSystem = new SoundSystem();
// g_shaderManager->applyShaderCache();
}
void axClientQuit() {
// g_shaderManager->saveShaderCache();
SafeDelete(g_soundSystem);
g_inputSystem->finalize();
SafeDelete(g_inputSystem);
g_defaultFont.clear();
g_consoleFont.clear();
g_miniFont.clear();
#ifdef AX_CONFIG_OPTION_USE_SPEEDTREE_40
g_renderSystem->removeEntityManager(g_treeManager);
SafeDelete(g_treeManager);
#endif // AX_CONFIG_OPTION_USE_SPEEDTREE_40
g_fontFactory->finalize();
g_assetManager->removeType(Asset::kFont);
SafeDelete(g_fontFactory);
g_assetManager->removeType(RenderMaterial::AssetType);
SafeDelete(gMaterialFactory);
g_renderSystem->finalize();
SafeDelete(g_renderSystem);
g_renderQueue->finalize();
SafeDelete(g_renderQueue);
}
} // namespace Axon
void FontTranslator::parseAttribute(ScriptCompiler* compiler, FontPtr& pFont,
PropertyAbstractNode* prop)
{
String& attrib = prop->name;
String val;
if (attrib == "glyph")
{
float coords[4];
if (prop->values.size() != 5 || !getString(prop->values.front(), &val) ||
!getFloats(++prop->values.begin(), prop->values.end(), coords, 4))
{
compiler->addError(ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line);
return;
}
// Set
// Support numeric and character glyph specification
Font::CodePoint cp;
if (val.size() > 1 && val[0] == 'u')
{
// Unicode glyph spec
String trimmed = val.substr(1);
cp = StringConverter::parseUnsignedInt(trimmed);
}
else
{
// Direct character
cp = val[0];
}
pFont->setGlyphTexCoords(cp, coords[0], coords[1], coords[2], coords[3],
1.0); // assume image is square
}
else if (attrib == "antialias_colour")
{
bool flag;
if (prop->values.empty() || !getBoolean(prop->values.front(), &flag))
{
compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
return;
}
pFont->setAntialiasColour(flag);
}
else if (attrib == "code_points")
{
if (prop->values.empty())
{
compiler->addError(ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line);
return;
}
for (auto& v : prop->values)
{
bool succ = getString(v, &val);
StringVector itemVec = StringUtil::split(val, "-");
if (succ && itemVec.size() == 2)
{
pFont->addCodePointRange(
Font::CodePointRange(StringConverter::parseUnsignedInt(itemVec[0]),
StringConverter::parseUnsignedInt(itemVec[1])));
}
}
}
else if (prop->values.empty() || !getString(prop->values.front(), &val) ||
!pFont->setParameter(attrib, val))
{
compiler->addError(ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line);
}
}
