mirror of
https://github.com/OpenMW/openmw.git
synced 2025-10-31 06:56:38 +00:00
700 lines
31 KiB
C++
700 lines
31 KiB
C++
#include "fontloader.hpp"
|
||
|
||
#include <array>
|
||
#include <stdexcept>
|
||
#include <string_view>
|
||
|
||
#include <osg/Image>
|
||
|
||
#include <osgDB/WriteFile>
|
||
|
||
#include <MyGUI_FactoryManager.h>
|
||
#include <MyGUI_RenderManager.h>
|
||
#include <MyGUI_ResourceManager.h>
|
||
#include <MyGUI_ResourceManualFont.h>
|
||
#include <MyGUI_ResourceTrueTypeFont.h>
|
||
#include <MyGUI_XmlDocument.h>
|
||
|
||
#include <components/debug/debuglog.hpp>
|
||
|
||
#include <components/fallback/fallback.hpp>
|
||
|
||
#include <components/vfs/manager.hpp>
|
||
|
||
#include <components/misc/strings/algorithm.hpp>
|
||
|
||
#include <components/myguiplatform/scalinglayer.hpp>
|
||
|
||
#include <components/settings/values.hpp>
|
||
|
||
namespace
|
||
{
|
||
MyGUI::xml::ElementPtr getProperty(MyGUI::xml::ElementPtr resourceNode, std::string_view propertyName)
|
||
{
|
||
MyGUI::xml::ElementPtr propertyNode = nullptr;
|
||
MyGUI::xml::ElementEnumerator propertyIterator = resourceNode->getElementEnumerator();
|
||
while (propertyIterator.next("Property"))
|
||
{
|
||
if (propertyIterator->findAttribute("key") == propertyName)
|
||
{
|
||
propertyNode = propertyIterator.current();
|
||
break;
|
||
}
|
||
}
|
||
|
||
return propertyNode;
|
||
}
|
||
|
||
MyGUI::IntSize getBookSize(MyGUI::IDataStream* layersStream)
|
||
{
|
||
MyGUI::xml::Document xmlDocument;
|
||
xmlDocument.open(layersStream);
|
||
MyGUI::xml::ElementPtr root = xmlDocument.getRoot();
|
||
MyGUI::xml::ElementEnumerator layersIterator = root->getElementEnumerator();
|
||
while (layersIterator.next("Layer"))
|
||
{
|
||
if (layersIterator->findAttribute("name") == "JournalBooks")
|
||
{
|
||
MyGUI::xml::ElementPtr sizeProperty = getProperty(layersIterator.current(), "Size");
|
||
if (sizeProperty != nullptr)
|
||
{
|
||
auto sizeValue = sizeProperty->findAttribute("value");
|
||
if (!sizeValue.empty())
|
||
return MyGUI::IntSize::parse(sizeValue);
|
||
}
|
||
}
|
||
}
|
||
|
||
return MyGUI::RenderManager::getInstance().getViewSize();
|
||
}
|
||
|
||
unsigned long utf8ToUnicode(std::string_view utf8)
|
||
{
|
||
if (utf8.empty())
|
||
return 0;
|
||
size_t i = 0;
|
||
unsigned long unicode;
|
||
size_t numbytes;
|
||
unsigned char ch = utf8[i++];
|
||
if (ch <= 0x7F)
|
||
{
|
||
unicode = ch;
|
||
numbytes = 0;
|
||
}
|
||
else if (ch <= 0xBF)
|
||
{
|
||
throw std::logic_error("not a UTF-8 string");
|
||
}
|
||
else if (ch <= 0xDF)
|
||
{
|
||
unicode = ch & 0x1F;
|
||
numbytes = 1;
|
||
}
|
||
else if (ch <= 0xEF)
|
||
{
|
||
unicode = ch & 0x0F;
|
||
numbytes = 2;
|
||
}
|
||
else if (ch <= 0xF7)
|
||
{
|
||
unicode = ch & 0x07;
|
||
numbytes = 3;
|
||
}
|
||
else
|
||
{
|
||
throw std::logic_error("not a UTF-8 string");
|
||
}
|
||
for (size_t j = 0; j < numbytes; ++j)
|
||
{
|
||
ch = utf8[i++];
|
||
if (ch < 0x80 || ch > 0xBF)
|
||
throw std::logic_error("not a UTF-8 string");
|
||
unicode <<= 6;
|
||
unicode += ch & 0x3F;
|
||
}
|
||
if (unicode >= 0xD800 && unicode <= 0xDFFF)
|
||
throw std::logic_error("not a UTF-8 string");
|
||
if (unicode > 0x10FFFF)
|
||
throw std::logic_error("not a UTF-8 string");
|
||
|
||
return unicode;
|
||
}
|
||
|
||
/// This is a hack for Polish font
|
||
unsigned char mapUtf8Char(unsigned char c)
|
||
{
|
||
switch (c)
|
||
{
|
||
case 0x80:
|
||
return 0xc6;
|
||
case 0x81:
|
||
return 0x9c;
|
||
case 0x82:
|
||
return 0xe6;
|
||
case 0x83:
|
||
return 0xb3;
|
||
case 0x84:
|
||
return 0xf1;
|
||
case 0x85:
|
||
return 0xb9;
|
||
case 0x86:
|
||
return 0xbf;
|
||
case 0x87:
|
||
return 0x9f;
|
||
case 0x88:
|
||
return 0xea;
|
||
case 0x89:
|
||
return 0xea;
|
||
case 0x8a:
|
||
return 0x00; // not contained in win1250
|
||
case 0x8b:
|
||
return 0x00; // not contained in win1250
|
||
case 0x8c:
|
||
return 0x8f;
|
||
case 0x8d:
|
||
return 0xaf;
|
||
case 0x8e:
|
||
return 0xa5;
|
||
case 0x8f:
|
||
return 0x8c;
|
||
case 0x90:
|
||
return 0xca;
|
||
case 0x93:
|
||
return 0xa3;
|
||
case 0x94:
|
||
return 0xf6;
|
||
case 0x95:
|
||
return 0xf3;
|
||
case 0x96:
|
||
return 0xaf;
|
||
case 0x97:
|
||
return 0x8f;
|
||
case 0x99:
|
||
return 0xd3;
|
||
case 0x9a:
|
||
return 0xd1;
|
||
case 0x9c:
|
||
return 0x00; // not contained in win1250
|
||
case 0xa0:
|
||
return 0xb9;
|
||
case 0xa1:
|
||
return 0xaf;
|
||
case 0xa2:
|
||
return 0xf3;
|
||
case 0xa3:
|
||
return 0xbf;
|
||
case 0xa4:
|
||
return 0x00; // not contained in win1250
|
||
case 0xe1:
|
||
return 0x8c;
|
||
case 0xe3:
|
||
return 0x00; // not contained in win1250
|
||
case 0xf5:
|
||
return 0x00; // not contained in win1250
|
||
default:
|
||
return c;
|
||
}
|
||
}
|
||
|
||
// getUnicode includes various hacks for dealing with Morrowind's .fnt files that are *mostly*
|
||
// in the expected win12XX encoding, but also have randomly swapped characters sometimes.
|
||
// Looks like the Morrowind developers found standard encodings too boring and threw in some twists for fun.
|
||
unsigned long getUnicode(unsigned char c, ToUTF8::Utf8Encoder& encoder, ToUTF8::FromType encoding)
|
||
{
|
||
if (encoding == ToUTF8::WINDOWS_1250) // Hack for polish font
|
||
{
|
||
const std::array<char, 2> str{ static_cast<char>(mapUtf8Char(c)), '\0' };
|
||
return utf8ToUnicode(encoder.getUtf8(std::string_view(str.data(), 1)));
|
||
}
|
||
else
|
||
{
|
||
const std::array<char, 2> str{ static_cast<char>(c), '\0' };
|
||
return utf8ToUnicode(encoder.getUtf8(std::string_view(str.data(), 1)));
|
||
}
|
||
}
|
||
|
||
[[noreturn]] void fail(std::istream& stream, std::string_view fileName, std::string_view message)
|
||
{
|
||
std::stringstream error;
|
||
error << "Font loading error: " << message;
|
||
error << "\n File: " << fileName;
|
||
error << "\n Offset: 0x" << std::hex << stream.tellg();
|
||
throw std::runtime_error(error.str());
|
||
}
|
||
|
||
}
|
||
|
||
namespace Gui
|
||
{
|
||
|
||
FontLoader::FontLoader(ToUTF8::FromType encoding, const VFS::Manager* vfs, float scalingFactor, bool exportFonts)
|
||
: mVFS(vfs)
|
||
, mScalingFactor(scalingFactor)
|
||
, mExportFonts(exportFonts)
|
||
{
|
||
if (encoding == ToUTF8::WINDOWS_1252)
|
||
mEncoding = ToUTF8::CP437;
|
||
else
|
||
mEncoding = encoding;
|
||
|
||
MyGUI::ResourceManager::getInstance().unregisterLoadXmlDelegate("Resource");
|
||
MyGUI::ResourceManager::getInstance().registerLoadXmlDelegate("Resource")
|
||
= MyGUI::newDelegate(this, &FontLoader::overrideLineHeight);
|
||
|
||
loadFonts();
|
||
}
|
||
|
||
void FontLoader::loadFonts()
|
||
{
|
||
std::string defaultFont{ Fallback::Map::getString("Fonts_Font_0") };
|
||
std::string scrollFont{ Fallback::Map::getString("Fonts_Font_2") };
|
||
loadFont(defaultFont, "DefaultFont");
|
||
loadFont(scrollFont, "ScrollFont");
|
||
loadFont("DejaVuLGCSansMono",
|
||
"MonoFont"); // We need to use a TrueType monospace font to display debug texts properly.
|
||
|
||
// Use our TrueType fonts as a fallback.
|
||
if (!MyGUI::ResourceManager::getInstance().isExist("DefaultFont")
|
||
&& !Misc::StringUtils::ciEqual(defaultFont, "MysticCards"))
|
||
loadFont("MysticCards", "DefaultFont");
|
||
if (!MyGUI::ResourceManager::getInstance().isExist("ScrollFont")
|
||
&& !Misc::StringUtils::ciEqual(scrollFont, "DemonicLetters"))
|
||
loadFont("DemonicLetters", "ScrollFont");
|
||
}
|
||
|
||
void FontLoader::loadFont(const std::string& fileName, const std::string& fontId)
|
||
{
|
||
if (mVFS->exists("fonts/" + fileName + ".fnt"))
|
||
loadBitmapFont(fileName + ".fnt", fontId);
|
||
else if (mVFS->exists("fonts/" + fileName + ".omwfont"))
|
||
loadTrueTypeFont(fileName + ".omwfont", fontId);
|
||
else
|
||
Log(Debug::Error) << "Font '" << fileName << "' is not found.";
|
||
}
|
||
|
||
void FontLoader::loadTrueTypeFont(const std::string& fileName, const std::string& fontId)
|
||
{
|
||
Log(Debug::Info) << "Loading font file " << fileName;
|
||
|
||
osgMyGUI::DataManager* dataManager
|
||
= dynamic_cast<osgMyGUI::DataManager*>(&osgMyGUI::DataManager::getInstance());
|
||
if (!dataManager)
|
||
{
|
||
Log(Debug::Error) << "Can not load TrueType font " << fontId << ": osgMyGUI::DataManager is not available.";
|
||
return;
|
||
}
|
||
|
||
// TODO: it may be worth to take in account resolution change, but it is not safe to replace used assets
|
||
std::unique_ptr<MyGUI::IDataStream> layersStream(dataManager->getData("openmw_layers.xml"));
|
||
MyGUI::IntSize bookSize = getBookSize(layersStream.get());
|
||
float bookScale = osgMyGUI::ScalingLayer::getScaleFactor(bookSize);
|
||
|
||
const auto oldDataPath = dataManager->getDataPath({});
|
||
dataManager->setResourcePath("fonts");
|
||
std::unique_ptr<MyGUI::IDataStream> dataStream(dataManager->getData(fileName));
|
||
|
||
MyGUI::xml::Document xmlDocument;
|
||
xmlDocument.open(dataStream.get());
|
||
MyGUI::xml::ElementPtr root = xmlDocument.getRoot();
|
||
|
||
MyGUI::xml::ElementEnumerator resourceNode = root->getElementEnumerator();
|
||
bool valid = false;
|
||
if (resourceNode.next("Resource"))
|
||
{
|
||
valid = resourceNode->findAttribute("type") == "ResourceTrueTypeFont";
|
||
}
|
||
|
||
if (valid == false)
|
||
{
|
||
dataManager->setResourcePath(oldDataPath);
|
||
Log(Debug::Error) << "Can not load TrueType font " << fontId << ": " << fileName << " is invalid.";
|
||
return;
|
||
}
|
||
|
||
int resolution = 70;
|
||
MyGUI::xml::ElementPtr resolutionNode = getProperty(resourceNode.current(), "Resolution");
|
||
if (resolutionNode == nullptr)
|
||
{
|
||
resolutionNode = resourceNode->createChild("Property");
|
||
resolutionNode->addAttribute("key", "Resolution");
|
||
}
|
||
else
|
||
resolution = MyGUI::utility::parseInt(resolutionNode->findAttribute("value"));
|
||
|
||
resolutionNode->setAttribute("value", MyGUI::utility::toString(resolution * std::ceil(mScalingFactor)));
|
||
|
||
MyGUI::xml::ElementPtr sizeNode = resourceNode->createChild("Property");
|
||
sizeNode->addAttribute("key", "Size");
|
||
sizeNode->addAttribute("value", std::to_string(Settings::gui().mFontSize));
|
||
|
||
MyGUI::ResourceTrueTypeFont* font = static_cast<MyGUI::ResourceTrueTypeFont*>(
|
||
MyGUI::FactoryManager::getInstance().createObject("Resource", "ResourceTrueTypeFont"));
|
||
font->deserialization(resourceNode.current(), MyGUI::Version(3, 2, 0));
|
||
font->setResourceName(fontId);
|
||
MyGUI::ResourceManager::getInstance().addResource(font);
|
||
|
||
resolutionNode->setAttribute(
|
||
"value", MyGUI::utility::toString(static_cast<int>(resolution * bookScale * mScalingFactor)));
|
||
|
||
MyGUI::ResourceTrueTypeFont* bookFont = static_cast<MyGUI::ResourceTrueTypeFont*>(
|
||
MyGUI::FactoryManager::getInstance().createObject("Resource", "ResourceTrueTypeFont"));
|
||
bookFont->deserialization(resourceNode.current(), MyGUI::Version(3, 2, 0));
|
||
bookFont->setResourceName("Journalbook " + fontId);
|
||
MyGUI::ResourceManager::getInstance().addResource(bookFont);
|
||
|
||
dataManager->setResourcePath(oldDataPath);
|
||
|
||
if (resourceNode.next("Resource"))
|
||
Log(Debug::Warning) << "Font file " << fileName
|
||
<< " contains multiple Resource entries, only first one will be used.";
|
||
}
|
||
|
||
typedef struct
|
||
{
|
||
float x;
|
||
float y;
|
||
} Point;
|
||
|
||
typedef struct
|
||
{
|
||
float u1; // appears unused, always 0
|
||
Point top_left;
|
||
Point top_right;
|
||
Point bottom_left;
|
||
Point bottom_right;
|
||
float width;
|
||
float height;
|
||
float kerningLeft;
|
||
float kerningRight;
|
||
float ascent;
|
||
} GlyphInfo;
|
||
|
||
void FontLoader::loadBitmapFont(const std::string& fileName, const std::string& fontId)
|
||
{
|
||
Log(Debug::Info) << "Loading font file " << fileName;
|
||
|
||
Files::IStreamPtr file = mVFS->get("fonts/" + fileName);
|
||
|
||
float fontSize;
|
||
file->read((char*)&fontSize, sizeof(fontSize));
|
||
if (!file->good())
|
||
fail(*file, fileName, "File too small to be a valid font");
|
||
|
||
int one;
|
||
file->read((char*)&one, sizeof(one));
|
||
if (!file->good())
|
||
fail(*file, fileName, "File too small to be a valid font");
|
||
|
||
if (one != 1)
|
||
fail(*file, fileName, "Unexpected value");
|
||
|
||
file->read((char*)&one, sizeof(one));
|
||
if (!file->good())
|
||
fail(*file, fileName, "File too small to be a valid font");
|
||
|
||
if (one != 1)
|
||
fail(*file, fileName, "Unexpected value");
|
||
|
||
char name_[284];
|
||
file->read(name_, sizeof(name_));
|
||
if (!file->good())
|
||
fail(*file, fileName, "File too small to be a valid font");
|
||
|
||
GlyphInfo data[256];
|
||
file->read((char*)data, sizeof(data));
|
||
if (!file->good())
|
||
fail(*file, fileName, "File too small to be a valid font");
|
||
|
||
file.reset();
|
||
|
||
// Create the font texture
|
||
const std::string name(name_);
|
||
const std::string bitmapFilename = "fonts/" + name + ".tex";
|
||
|
||
Files::IStreamPtr bitmapFile = mVFS->get(bitmapFilename);
|
||
|
||
int width, height;
|
||
bitmapFile->read((char*)&width, sizeof(int));
|
||
bitmapFile->read((char*)&height, sizeof(int));
|
||
|
||
if (!bitmapFile->good())
|
||
fail(*bitmapFile, bitmapFilename, "File too small to be a valid bitmap");
|
||
|
||
if (width <= 0 || height <= 0)
|
||
fail(*bitmapFile, bitmapFilename, "Width and height must be positive");
|
||
|
||
std::vector<char> textureData;
|
||
textureData.resize(width * height * 4);
|
||
bitmapFile->read(textureData.data(), width * height * 4);
|
||
if (!bitmapFile->good())
|
||
Log(Debug::Warning) << "Font bitmap " << bitmapFilename << " ended prematurely, using partial data ("
|
||
<< bitmapFile->gcount() << "/" << (width * height * 4) << " bytes)";
|
||
bitmapFile.reset();
|
||
|
||
if (mExportFonts)
|
||
{
|
||
osg::ref_ptr<osg::Image> image = new osg::Image;
|
||
image->allocateImage(width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE);
|
||
assert(image->isDataContiguous());
|
||
memcpy(image->data(), textureData.data(), textureData.size());
|
||
// Convert to OpenGL origin for sensible output
|
||
image->flipVertical();
|
||
|
||
Log(Debug::Info) << "Writing " << name + ".png";
|
||
osgDB::writeImageFile(*image, name + ".png");
|
||
}
|
||
|
||
MyGUI::ITexture* tex = MyGUI::RenderManager::getInstance().createTexture(bitmapFilename);
|
||
tex->createManual(width, height, MyGUI::TextureUsage::Write, MyGUI::PixelFormat::R8G8B8A8);
|
||
unsigned char* texData = reinterpret_cast<unsigned char*>(tex->lock(MyGUI::TextureUsage::Write));
|
||
memcpy(texData, textureData.data(), textureData.size());
|
||
tex->unlock();
|
||
|
||
// We need to emulate loading from XML because the data members are private as of mygui 3.2.0
|
||
MyGUI::xml::Document xmlDocument;
|
||
MyGUI::xml::ElementPtr root = xmlDocument.createRoot("ResourceManualFont");
|
||
|
||
root->addAttribute("name", fontId);
|
||
|
||
MyGUI::xml::ElementPtr defaultHeight = root->createChild("Property");
|
||
defaultHeight->addAttribute("key", "DefaultHeight");
|
||
defaultHeight->addAttribute("value", fontSize);
|
||
MyGUI::xml::ElementPtr source = root->createChild("Property");
|
||
source->addAttribute("key", "Source");
|
||
source->addAttribute("value", bitmapFilename);
|
||
MyGUI::xml::ElementPtr codes = root->createChild("Codes");
|
||
|
||
// Fall back from unavailable Win-1252 encoding symbols to similar characters available in CP-437 game fonts
|
||
// Generally, that is, as this tries to follow Morrowind's interesting substitution logic
|
||
|
||
using FallbackIndex = unsigned int;
|
||
using UnicodeIndex = unsigned int;
|
||
std::multimap<FallbackIndex, UnicodeIndex> additional;
|
||
|
||
// Some symbols must not be shown altogether
|
||
std::vector<UnicodeIndex> omitted;
|
||
|
||
// Ignored madness: caret ^ (available in the font!) uses percent sign % glyph
|
||
// We do not differentiate between glyphs that are always considered missing and glyphs that are not replaced
|
||
// because there's (probably?) no point
|
||
|
||
// € (Euro Sign, 0x80/U+20AC) is replaced with underscore
|
||
// 0x81 (unused) is replaced with underscore
|
||
additional.emplace(44, 0x201A); // ‚ (Single Low-9 Quotation Mark, 0x82) => , (comma)
|
||
// ƒ (Latin Small Letter F with Hook, 0x83) is unavailable, not replaced
|
||
additional.emplace(44, 0x201E); // „ (Double Low-9 Quotation Mark, 0x84) => , (comma)
|
||
additional.emplace(46, 0x2026); // … (Horizontal Ellipsis, 0x85) => . (period)
|
||
additional.emplace(43, 0x2020); // † (Dagger, 0x86) => + (plus sign)
|
||
additional.emplace(216, 0x2021); // ‡ (Double Dagger, 0x87) => ╫
|
||
additional.emplace(94, 0x02C6); // ˆ (Modifier Letter Circumflex Accent, 0x88) => ^ (caret)
|
||
additional.emplace(37, 0x2030); // ‰ (Per Mille Sign, 0x89) => % (percent sign)
|
||
additional.emplace(83, 0x0160); // Š (Latin Capital Letter S with Caron, 0x8A) => S (latin capital S)
|
||
additional.emplace(60, 0x2039); // ‹ (Single Left-Pointing Angle Quotation Mark, 0x8B) => < (less-than)
|
||
additional.emplace(79, 0x0152); // Π(Latin Capital Ligature Oe, 0x8C) => O (latin capital O)
|
||
// 0x8D (unused) is replaced with underscore
|
||
additional.emplace(90, 0x017D); // Ž (Latin Capital Letter Z with Caron, 0x8E) => Z (latin capital Z)
|
||
// 0x8F (unused) is replaced with underscore
|
||
// 0x90 (unused) is replaced with underscore
|
||
additional.emplace(39, 0x2018); // ‘ (Left Single Quotation Mark, 0x91) => ' (apostrophe) (MW: backtick)
|
||
additional.emplace(39, 0x2019); // ’ (Right Single Quotation Mark, 0x92) => ' (apostrophe)
|
||
additional.emplace(34, 0x201C); // “ (Left Double Quotation Mark, 0x93) => " (double quote mark)
|
||
additional.emplace(34, 0x201D); // ” (Right Double Quotation Mark, 0x94) => " (double quote mark)
|
||
omitted.push_back(0x2022); // • (Bullet, 0x95)
|
||
additional.emplace(45, 0x2013); // – (En Dash, 0x96) => - (hyphen)
|
||
additional.emplace(45, 0x2014); // — (Em Dash, 0x97) => - (hyphen)
|
||
additional.emplace(126, 0x02DC); // ˜ (Small Tilde, 0x98) => ~ (tilde)
|
||
additional.emplace(84, 0x2122); // ™ (Trade Mark Sign, 0x99) => T (latin capital T)
|
||
additional.emplace(115, 0x0161); // š (Latin Small Letter S with Caron, 0x9A) => s (latin small S)
|
||
additional.emplace(62, 0x203A); // › (Single Right-Pointing Angle Quotation Mark, 0x9B) => > (greater-than)
|
||
additional.emplace(111, 0x0153); // œ (Latin Small Ligature Oe, 0x9C) => o (latin small O)
|
||
// 0x9D (unused) is replaced with underscore
|
||
additional.emplace(122, 0x017E); // ž (Latin Small Letter Z with Caron, 0x9E) => z (latin small Z)
|
||
additional.emplace(89, 0x0178); // Ÿ (Latin Capital Letter Y with Diaeresis, 0x9F) => Y (latin capital Y)
|
||
// Nbsp (No-Break Space, 0xA0) is unavailable, not replaced
|
||
// ¡ (Inverted Exclamation Mark, 0xA1) is unavailable, not replaced
|
||
// ¢ (Cent Sign, 0xA2) is unavailable, not replaced
|
||
// £ (Pound Sign, 0xA3) is available but its glyph looks like œ (small oe ligature)
|
||
omitted.push_back(0x00A4); // ¤ (Currency Sign)
|
||
// ¥ (Yen Sign, 0xA5) is unavailable, not replaced
|
||
additional.emplace(221, 0x00A6); // ¦ (Broken Bar, 0xA6) => ▌
|
||
omitted.push_back(0x00A7); // § (Section Sign)
|
||
additional.emplace(34, 0x00A8); // ¨ (Diaeresis) => " (double quote mark)
|
||
additional.emplace(99, 0x00A9); // © (Copyright Sign) => c (latin small C)
|
||
// ª (Feminine Ordinal Indicator, 0xAA) is unavailable, not replaced
|
||
// « (Left-Pointing Double Angle Quotation Mark, 0xAB) is unavailable, not replaced
|
||
// ¬ (Not Sign, 0xAC) is unavailable, not replaced
|
||
additional.emplace(45, 0x00AD); // Soft Hyphen => - (hyphen)
|
||
additional.emplace(114, 0x00AE); // ® (Registered Sign) => r (latin small R)
|
||
additional.emplace(95, 0x00AF); // ¯ (Macron) => _ (underscore)
|
||
// ° (Degree Sign, 0xB0) is unavailable, not replaced
|
||
// ± (Plus-Minus Sign, 0xB1) is unavailable, not replaced
|
||
// ² (Superscript Two, 0xB2) is unavailable, not replaced
|
||
additional.emplace(51, 0x00B3); // ³ (Superscript Three) => 3 (three digit)
|
||
additional.emplace(39, 0x00B4); // ´ (Acute Accent) => ' (apostrophe)
|
||
// µ (Micro Sign, 0xB5) is unavailable, not replaced
|
||
omitted.push_back(0x00B6); // ¶ (Pilcrow Sign)
|
||
// · (Middle Dot, 0xB7) is unavailable, not replaced
|
||
additional.emplace(44, 0x00B8); // ¸ (Cedilla) => , (comma)
|
||
additional.emplace(49, 0x00B9); // ¹ (Superscript One) => 1 (one digit)
|
||
// º (Masculine Ordinal Indicator, 0xBA) is unavailable, not replaced
|
||
// » (Right-Pointing Double Angle Quotation Mark, 0xBB) is unavailable, not replaced
|
||
// ¼ (Vulgar Fraction One Quarter, 0xBC) is unavailable, not replaced
|
||
// ½ (Vulgar Fraction One Half, 0xBD) is unavailable, not replaced
|
||
// ¾ (Vulgar Fraction Three Quarters, 0xBE) is replaced with underscore
|
||
// ¿ (Inverted Question Mark, 0xBF) is unavailable, not replaced
|
||
additional.emplace(65, 0x00C0); // À (Latin Capital Letter A with Grave) => A (latin capital A)
|
||
additional.emplace(65, 0x00C1); // Á (Latin Capital Letter A with Acute) => A (latin capital A)
|
||
additional.emplace(65, 0x00C2); // Â (Latin Capital Letter A with Circumflex) => A (latin capital A)
|
||
additional.emplace(65, 0x00C3); // Ã (Latin Capital Letter A with Tilde) => A (latin capital A)
|
||
// Ä (Latin Capital Letter A with Diaeresis, 0xC4) is available
|
||
// Å (Latin Capital Letter A with Ring Above, 0xC5) is available
|
||
// Æ (Latin Capital Letter Ae, 0xC6) is unavailable, not replaced
|
||
// Ç (Latin Capital Letter C with Cedilla, 0xC7) is available
|
||
additional.emplace(69, 0x00C8); // È (Latin Capital Letter E with Grave) => E (latin capital E)
|
||
// É (Latin Capital Letter E with Acute, 0xC9) is available
|
||
additional.emplace(69, 0x00CA); // Ê (Latin Capital Letter E with Circumflex) => E (latin capital E)
|
||
additional.emplace(69, 0x00CB); // Ë (Latin Capital Letter E with Diaeresis) => E (latin capital E)
|
||
additional.emplace(73, 0x00CC); // Ì (Latin Capital Letter I with Grave) => I (latin capital I)
|
||
additional.emplace(73, 0x00CD); // Í (Latin Capital Letter I with Acute) => I (latin capital I)
|
||
additional.emplace(73, 0x00CE); // Î (Latin Capital Letter I with Circumflex) => I (latin capital I)
|
||
additional.emplace(73, 0x00CF); // Ï (Latin Capital Letter I with Diaeresis) => I (latin capital I)
|
||
additional.emplace(68, 0x00D0); // Ð (Latin Capital Letter Eth) => D (latin capital D)
|
||
// Ñ (Latin Capital Letter N with Tilde, 0xD1) is unavailable, not replaced
|
||
additional.emplace(79, 0x00D2); // Ò (Latin Capital Letter O with Grave) => O (latin capital O)
|
||
additional.emplace(79, 0x00D3); // Ó (Latin Capital Letter O with Acute) => O (latin capital O)
|
||
additional.emplace(79, 0x00D4); // Ô (Latin Capital Letter O with Circumflex) => O (latin capital O)
|
||
additional.emplace(79, 0x00D5); // Õ (Latin Capital Letter O with Tilde) => O (latin capital O)
|
||
// Ö (Latin Capital Letter O with Diaeresis, 0xD6) is available
|
||
additional.emplace(120, 0x00D7); // × (Multiplication Sign) => x (latin small X)
|
||
additional.emplace(79, 0x00D8); // Ø (Latin Capital Letter O with Stroke) => O (latin capital O)
|
||
additional.emplace(85, 0x00D9); // Ù (Latin Capital Letter U with Grave) => U (latin capital U)
|
||
additional.emplace(85, 0x00DA); // Ú (Latin Capital Letter U with Acute) => U (latin capital U)
|
||
additional.emplace(85, 0x00DB); // Û (Latin Capital Letter U with Circumflex) => U (latin capital U)
|
||
// Ü (Latin Capital Letter U with Diaeresis, 0xDC) is available
|
||
additional.emplace(89, 0x00DD); // Ý (Latin Capital Letter Y with Acute) => Y (latin capital Y)
|
||
// 0xDE to 0xFF are generally not replaced with certain exceptions
|
||
additional.emplace(97, 0x00E3); // ã (Latin Small Letter A with Tilde) => a (latin small A)
|
||
additional.emplace(100, 0x00F0); // ð (Latin Small Letter Eth) => d (latin small D)
|
||
additional.emplace(111, 0x00F5); // õ (Latin Small Letter O with Tilde) => o (latin small O)
|
||
additional.emplace(111, 0x00F8); // ø (Latin Small Letter O with Stroke) => o (latin small O)
|
||
additional.emplace(121, 0x00FD); // ý (Latin Small Letter Y with Acute) => y (latin small Y)
|
||
|
||
// Russian Morrowind which uses Win-1251 encoding only does equivalent (often garbage) Win-1252 replacements
|
||
// However, we'll provide custom replacements for Cyrillic io letters
|
||
// These letters aren't a part of any content but they are printable
|
||
additional.emplace(69, 0x0401); // Ё (Cyrillic Capital Letter Io) => E (latin capital E)
|
||
additional.emplace(137, 0x0451); // ё (Cyrillic Small Letter Io) => ë (latin small E-diaeresis)
|
||
|
||
// ASCII vertical bar, use this as text input cursor
|
||
additional.emplace(124, MyGUI::FontCodeType::Cursor);
|
||
|
||
// Underscore, use for NotDefined marker (used for glyphs not existing in the font)
|
||
additional.emplace(95, MyGUI::FontCodeType::NotDefined);
|
||
|
||
for (int i = 0; i < 256; i++)
|
||
{
|
||
float x1 = data[i].top_left.x * width;
|
||
float y1 = data[i].top_left.y * height;
|
||
float w = data[i].top_right.x * width - x1;
|
||
float h = data[i].bottom_left.y * height - y1;
|
||
|
||
ToUTF8::Utf8Encoder encoder(mEncoding);
|
||
unsigned long unicodeVal = getUnicode(i, encoder, mEncoding);
|
||
const std::string coord = MyGUI::utility::toString(x1) + " " + MyGUI::utility::toString(y1) + " "
|
||
+ MyGUI::utility::toString(w) + " " + MyGUI::utility::toString(h);
|
||
float advance = data[i].width + data[i].kerningRight;
|
||
// Yes MyGUI, we really do want an advance of 0 sometimes, thank you.
|
||
if (advance == 0.f && data[i].width != 0.f)
|
||
advance = std::numeric_limits<float>::min();
|
||
const std::string bearing = MyGUI::utility::toString(data[i].kerningLeft) + ' '
|
||
+ MyGUI::utility::toString((fontSize - data[i].ascent));
|
||
const MyGUI::IntSize size(static_cast<int>(data[i].width), static_cast<int>(data[i].height));
|
||
|
||
MyGUI::xml::ElementPtr code = codes->createChild("Code");
|
||
code->addAttribute("index", unicodeVal);
|
||
code->addAttribute("coord", coord);
|
||
code->addAttribute("advance", advance);
|
||
code->addAttribute("bearing", bearing);
|
||
code->addAttribute("size", size);
|
||
|
||
for (auto [it, end] = additional.equal_range(i); it != end; ++it)
|
||
{
|
||
code = codes->createChild("Code");
|
||
code->addAttribute("index", it->second);
|
||
code->addAttribute("coord", coord);
|
||
code->addAttribute("advance", advance);
|
||
code->addAttribute("bearing", bearing);
|
||
code->addAttribute("size", size);
|
||
}
|
||
}
|
||
|
||
// These are required as well, but the fonts don't provide them
|
||
omitted.push_back(MyGUI::FontCodeType::Selected);
|
||
omitted.push_back(MyGUI::FontCodeType::SelectedBack);
|
||
for (const UnicodeIndex index : omitted)
|
||
{
|
||
MyGUI::xml::ElementPtr code = codes->createChild("Code");
|
||
code->addAttribute("index", index);
|
||
code->addAttribute("coord", "0 0 0 0");
|
||
code->addAttribute("advance", "0");
|
||
code->addAttribute("bearing", "0 0");
|
||
code->addAttribute("size", "0 0");
|
||
}
|
||
|
||
if (mExportFonts)
|
||
{
|
||
Log(Debug::Info) << "Writing " << name + ".xml";
|
||
xmlDocument.createDeclaration();
|
||
xmlDocument.save(name + ".xml");
|
||
}
|
||
|
||
// Register the font with MyGUI
|
||
MyGUI::ResourceManualFont* font = static_cast<MyGUI::ResourceManualFont*>(
|
||
MyGUI::FactoryManager::getInstance().createObject("Resource", "ResourceManualFont"));
|
||
font->deserialization(root, MyGUI::Version(3, 2, 0));
|
||
|
||
MyGUI::ResourceManualFont* bookFont = static_cast<MyGUI::ResourceManualFont*>(
|
||
MyGUI::FactoryManager::getInstance().createObject("Resource", "ResourceManualFont"));
|
||
bookFont->deserialization(root, MyGUI::Version(3, 2, 0));
|
||
bookFont->setResourceName("Journalbook " + fontId);
|
||
|
||
MyGUI::ResourceManager::getInstance().addResource(font);
|
||
MyGUI::ResourceManager::getInstance().addResource(bookFont);
|
||
}
|
||
|
||
void FontLoader::overrideLineHeight(MyGUI::xml::ElementPtr _node, std::string_view _file, MyGUI::Version _version)
|
||
{
|
||
// We should adjust line height for MyGUI widgets depending on font size
|
||
MyGUI::xml::ElementEnumerator resourceNode = _node->getElementEnumerator();
|
||
while (resourceNode.next("Resource"))
|
||
{
|
||
auto type = resourceNode->findAttribute("type");
|
||
|
||
if (Misc::StringUtils::ciEqual(type, "ResourceLayout"))
|
||
{
|
||
MyGUI::xml::ElementEnumerator resourceRootNode = resourceNode->getElementEnumerator();
|
||
while (resourceRootNode.next("Widget"))
|
||
{
|
||
if (resourceRootNode->findAttribute("name") != "Root")
|
||
continue;
|
||
|
||
MyGUI::xml::ElementPtr heightNode = resourceRootNode->createChild("UserString");
|
||
heightNode->addAttribute("key", "HeightLine");
|
||
heightNode->addAttribute("value", std::to_string(Settings::gui().mFontSize + 2));
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
MyGUI::ResourceManager::getInstance().loadFromXmlNode(_node, _file, _version);
|
||
}
|
||
|
||
std::string_view FontLoader::getFontForFace(std::string_view face)
|
||
{
|
||
if (Misc::StringUtils::ciEqual(face, "daedric"))
|
||
return "ScrollFont";
|
||
|
||
return "DefaultFont";
|
||
}
|
||
}
|