Font: Overhaul font asset discovery

Previously, any font names requested by RGSS would be translated
directly to filenames by lowercasing and replacing spaces with
underscores (and finally doing some extension substitution).
To make this whole thing work smoother as well as get closer to
how font discovery is done in VX, we now scan the "Fonts/" folder
at startup and index all present font assets by their family name;
now, if an "Open Sans" font is present in "Fonts/", it will be
used regardless of filename.

Font assets with "Regular" style are preferred, but in their
absence, mkxp will make use of any other style it can find for
the respective family. This is not the exact same behavior as
VX, but it should cover 95% of use cases.

Previously, one could substitute fonts via filenames, ie. to
substitute "Arial" with "Open Sans", one would just rename
"OpenSans.ttf" to "arial.ttf" and put it in "Fonts/". With the
above change, this is no longer possible. As an alternative, one
can now explicitly specify font family substitutions via mkxp.conf;
eg. for the above case, one would add

fontSub=Arial>Open Sans

to the configuration file. Multiple such rules can be specified.

In the process, I also added the ability to provide
'Font.(default_)name' with an array of font families to search
for the first existing one instead of a plain string.
This makes the behavior closer to RMXP; however, it doesn't
work 100% the same: when a reference to the 'Font.name' array is
held and additional strings are added to it without re-assignig
the array to 'Font.name', those will be ignored.
This commit is contained in:
Jonas Kulla 2014-04-11 13:37:14 +02:00
parent 31626c9acc
commit 1ef6e04520
13 changed files with 443 additions and 185 deletions

View File

@ -52,12 +52,14 @@ RB_METHOD(bitmapInitialize)
setPrivateData(self, b); setPrivateData(self, b);
/* Wrap properties */ /* Wrap properties */
Font *font = new Font(); VALUE fontKlass = rb_const_get(rb_cObject, rb_intern("Font"));
b->setFont(font); VALUE fontObj = rb_obj_alloc(fontKlass);
font->setColor(new Color(*font->getColor())); rb_obj_call_init(fontObj, 0, 0);
VALUE fontProp = wrapProperty(self, font, "font", FontType); Font *font = getPrivateData<Font>(fontObj);
wrapProperty(fontProp, font->getColor(), "color", ColorType); b->setFont(font);
rb_iv_set(self, "font", fontObj);
return self; return self;
} }

View File

@ -23,6 +23,9 @@
#include "binding-util.h" #include "binding-util.h"
#include "binding-types.h" #include "binding-types.h"
#include "exception.h" #include "exception.h"
#include "sharedstate.h"
#include <string.h>
DEF_TYPE(Font); DEF_TYPE(Font);
@ -36,14 +39,16 @@ RB_METHOD(fontDoesExist)
return rb_bool_new(Font::doesExist(name)); return rb_bool_new(Font::doesExist(name));
} }
RB_METHOD(FontSetName);
RB_METHOD(fontInitialize) RB_METHOD(fontInitialize)
{ {
const char *name = 0; VALUE name = Qnil;
int size = 0; int size = 0;
rb_get_args(argc, argv, "|zi", &name, &size RB_ARG_END); rb_get_args(argc, argv, "|oi", &name, &size RB_ARG_END);
Font *f = new Font(name, size); Font *f = new Font(0, size);
setPrivateData(self, f); setPrivateData(self, f);
@ -51,6 +56,13 @@ RB_METHOD(fontInitialize)
f->setColor(new Color(*f->getColor())); f->setColor(new Color(*f->getColor()));
wrapProperty(self, f->getColor(), "color", ColorType); wrapProperty(self, f->getColor(), "color", ColorType);
if (NIL_P(name))
name = rb_iv_get(rb_obj_class(self), "default_name");
/* Going over the 'name=' function automatically causes
* a possbile name array to be re-verified for existing fonts */
FontSetName(1, &name, self);
return self; return self;
} }
@ -77,21 +89,63 @@ RB_METHOD(FontGetName)
{ {
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
Font *f = getPrivateData<Font>(self); return rb_iv_get(self, "name");
}
return rb_str_new_cstr(f->getName()); static void
fontSetNameHelper(VALUE self, int argc, VALUE *argv,
const char *nameIv, char *outBuf, size_t outLen)
{
rb_check_argc(argc, 1);
VALUE arg = argv[0];
int type = rb_type(arg);
// Fixme: in RGSS3, specifying "" (and only that) as font name results in
// no text being drawn (everything else is substituted with Arial I think)
strncpy(outBuf, "", outLen);
if (type == RUBY_T_STRING)
{
strncpy(outBuf, RSTRING_PTR(arg), outLen);
}
else if (type == RUBY_T_ARRAY)
{
for (long i = 0; i < RARRAY_LEN(arg); ++i)
{
VALUE str = rb_ary_entry(arg, i);
/* Non-string objects are tolerated (ignored) */
if (rb_type(str) != RUBY_T_STRING)
continue;
const char *family = RSTRING_PTR(str);
/* We only set the core Font object's name attribute
* to the actually existing font name */
if (!shState->fontState().fontPresent(family))
continue;
strncpy(outBuf, family, outLen);
}
}
/* RMXP doesn't even care if the argument type is
* something other than string/array. Whatever... */
rb_iv_set(self, nameIv, arg);
} }
RB_METHOD(FontSetName) RB_METHOD(FontSetName)
{ {
Font *f = getPrivateData<Font>(self); Font *f = getPrivateData<Font>(self);
VALUE name; char result[256];
rb_get_args(argc, argv, "S", &name RB_ARG_END); fontSetNameHelper(self, argc, argv, "default_name",
result, sizeof(result));
f->setName(RSTRING_PTR(name)); f->setName(result);
return name; return argv[0];
} }
#undef DEF_PROP_CHK_DISP #undef DEF_PROP_CHK_DISP
@ -124,18 +178,19 @@ DEF_KLASS_PROP(Font, bool, DefaultItalic, "b", rb_bool_new)
RB_METHOD(FontGetDefaultName) RB_METHOD(FontGetDefaultName)
{ {
RB_UNUSED_PARAM; RB_UNUSED_PARAM;
return rb_str_new_cstr(Font::getDefaultName());
return rb_iv_get(self, "default_name");
} }
RB_METHOD(FontSetDefaultName) RB_METHOD(FontSetDefaultName)
{ {
RB_UNUSED_PARAM; char result[256];
VALUE nameObj; fontSetNameHelper(self, argc, argv, "default_name",
rb_get_args(argc, argv, "S", &nameObj RB_ARG_END); result, sizeof(result));
Font::setDefaultName(RSTRING_PTR(nameObj)); Font::setDefaultName(result);
return nameObj; return argv[0];
} }
RB_METHOD(FontGetDefaultColor) RB_METHOD(FontGetDefaultColor)
@ -174,6 +229,7 @@ fontBindingInit()
Font::setDefaultColor(new Color(*Font::getDefaultColor())); Font::setDefaultColor(new Color(*Font::getDefaultColor()));
wrapProperty(klass, Font::getDefaultColor(), "default_color", ColorType); wrapProperty(klass, Font::getDefaultColor(), "default_color", ColorType);
rb_iv_set(klass, "default_name", rb_str_new_cstr(Font::getDefaultName()));
INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name"); INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size"); INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");

View File

@ -113,3 +113,18 @@
# RTP=/path/to/rtp1 # RTP=/path/to/rtp1
# RTP=/path/to/rtp2.zip # RTP=/path/to/rtp2.zip
# RTP=/path/to/game.rgssad # RTP=/path/to/game.rgssad
# Font substitutions allow drop-in replacements of fonts
# to be used without changing the RGSS scripts,
# eg. providing 'Open Sans' when the game thinkgs it's
# using 'Arial'. Font family to be substituted and
# replacement family are separated by one sole '>'.
# Be careful not to include any spaces.
# This is not connected to the built-in font, which is
# always used when a non-existing font family is
# requested by RGSS.
# (default: none)
#
# fontSub=Arial>Open Sans
# fontSub=Times New Roman>Liberation Serif

View File

@ -83,6 +83,7 @@ void Config::read(int argc, char *argv[])
podesc.add_options() podesc.add_options()
PO_DESC_ALL PO_DESC_ALL
("RTP", po::value<StringVec>()->composing()) ("RTP", po::value<StringVec>()->composing())
("fontSub", po::value<StringVec>()->composing())
; ;
po::variables_map vm; po::variables_map vm;
@ -115,6 +116,8 @@ void Config::read(int argc, char *argv[])
GUARD_ALL( rtps = vm["RTP"].as<StringVec>(); ); GUARD_ALL( rtps = vm["RTP"].as<StringVec>(); );
GUARD_ALL( fontSubs = vm["fontSub"].as<StringVec>(); );
#undef PO_DESC #undef PO_DESC
#undef PO_DESC_ALL #undef PO_DESC_ALL
} }

View File

@ -54,6 +54,8 @@ struct Config
std::string customScript; std::string customScript;
std::vector<std::string> rtps; std::vector<std::string> rtps;
std::vector<std::string> fontSubs;
/* Game INI contents */ /* Game INI contents */
struct { struct {
std::string scripts; std::string scripts;

View File

@ -21,6 +21,7 @@
#include "filesystem.h" #include "filesystem.h"
#include "font.h"
#include "util.h" #include "util.h"
#include "exception.h" #include "exception.h"
#include "boost-hash.h" #include "boost-hash.h"
@ -498,6 +499,99 @@ static const PHYSFS_Archiver RGSS_Archiver =
RGSS_closeArchive RGSS_closeArchive
}; };
static inline PHYSFS_File *sdlPHYS(SDL_RWops *ops)
{
return static_cast<PHYSFS_File*>(ops->hidden.unknown.data1);
}
static Sint64 SDL_RWopsSize(SDL_RWops *ops)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
return PHYSFS_fileLength(f);
}
static Sint64 SDL_RWopsSeek(SDL_RWops *ops, int64_t offset, int whence)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
int64_t base;
switch (whence)
{
default:
case RW_SEEK_SET :
base = 0;
break;
case RW_SEEK_CUR :
base = PHYSFS_tell(f);
break;
case RW_SEEK_END :
base = PHYSFS_fileLength(f);
break;
}
int result = PHYSFS_seek(f, base + offset);
return (result != 0) ? PHYSFS_tell(f) : -1;
}
static size_t SDL_RWopsRead(SDL_RWops *ops, void *buffer, size_t size, size_t maxnum)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return 0;
PHYSFS_sint64 result = PHYSFS_readBytes(f, buffer, size*maxnum);
return (result != -1) ? (result / size) : 0;
}
static size_t SDL_RWopsWrite(SDL_RWops *ops, const void *buffer, size_t size, size_t num)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return 0;
PHYSFS_sint64 result = PHYSFS_writeBytes(f, buffer, size*num);
return (result != -1) ? (result / size) : 0;
}
static int SDL_RWopsClose(SDL_RWops *ops)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
int result = PHYSFS_close(f);
f = 0;
return (result != 0) ? 0 : -1;
}
static int SDL_RWopsCloseFree(SDL_RWops *ops)
{
int result = SDL_RWopsClose(ops);
SDL_FreeRW(ops);
return result;
}
const Uint32 SDL_RWOPS_PHYSFS = SDL_RWOPS_UNKNOWN+10;
struct FileSystemPrivate struct FileSystemPrivate
{ {
/* Maps: lower case filename, To: actual (mixed case) filename. /* Maps: lower case filename, To: actual (mixed case) filename.
@ -650,6 +744,24 @@ struct FileSystemPrivate
return handle; return handle;
} }
void initReadOps(PHYSFS_File *handle,
SDL_RWops &ops,
bool freeOnClose)
{
ops.size = SDL_RWopsSize;
ops.seek = SDL_RWopsSeek;
ops.read = SDL_RWopsRead;
ops.write = SDL_RWopsWrite;
if (freeOnClose)
ops.close = SDL_RWopsCloseFree;
else
ops.close = SDL_RWopsClose;
ops.type = SDL_RWOPS_PHYSFS;
ops.hidden.unknown.data1 = handle;
}
}; };
FileSystem::FileSystem(const char *argv0, FileSystem::FileSystem(const char *argv0,
@ -746,98 +858,59 @@ void FileSystem::createPathCache()
p->havePathCache = true; p->havePathCache = true;
} }
static inline PHYSFS_File *sdlPHYS(SDL_RWops *ops) static void strToLower(std::string &str)
{ {
return static_cast<PHYSFS_File*>(ops->hidden.unknown.data1); for (size_t i = 0; i < str.size(); ++i)
str[i] = tolower(str[i]);
} }
static Sint64 SDL_RWopsSize(SDL_RWops *ops) struct FontSetsCBData
{ {
PHYSFS_File *f = sdlPHYS(ops); FileSystemPrivate *p;
SharedFontState *sfs;
};
if (!f) static void fontSetEnumCB(void *data, const char *,
return -1; const char *fname)
{
FontSetsCBData *d = static_cast<FontSetsCBData*>(data);
FileSystemPrivate *p = d->p;
return PHYSFS_fileLength(f); /* Only consider filenames with font extensions */
const char *ext = p->findExt(fname);
if (!ext)
return;
std::string lower(ext);
strToLower(lower);
if (!contains(p->extensions[FileSystem::Font], lower))
return;
std::string filename("Fonts/");
filename += fname;
PHYSFS_File *handle = PHYSFS_openRead(filename.c_str());
if (!handle)
return;
SDL_RWops ops;
p->initReadOps(handle, ops, false);
d->sfs->initFontSetCB(ops, filename);
SDL_RWclose(&ops);
} }
static Sint64 SDL_RWopsSeek(SDL_RWops *ops, int64_t offset, int whence) void FileSystem::initFontSets(SharedFontState &sfs)
{ {
PHYSFS_File *f = sdlPHYS(ops); FontSetsCBData d = { p, &sfs };
if (!f) PHYSFS_enumerateFilesCallback("Fonts", fontSetEnumCB, &d);
return -1;
int64_t base;
switch (whence)
{
default:
case RW_SEEK_SET :
base = 0;
break;
case RW_SEEK_CUR :
base = PHYSFS_tell(f);
break;
case RW_SEEK_END :
base = PHYSFS_fileLength(f);
break;
} }
int result = PHYSFS_seek(f, base + offset);
return (result != 0) ? PHYSFS_tell(f) : -1;
}
static size_t SDL_RWopsRead(SDL_RWops *ops, void *buffer, size_t size, size_t maxnum)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return 0;
PHYSFS_sint64 result = PHYSFS_readBytes(f, buffer, size*maxnum);
return (result != -1) ? (result / size) : 0;
}
static size_t SDL_RWopsWrite(SDL_RWops *ops, const void *buffer, size_t size, size_t num)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return 0;
PHYSFS_sint64 result = PHYSFS_writeBytes(f, buffer, size*num);
return (result != -1) ? (result / size) : 0;
}
static int SDL_RWopsClose(SDL_RWops *ops)
{
PHYSFS_File *f = sdlPHYS(ops);
if (!f)
return -1;
int result = PHYSFS_close(f);
f = 0;
return (result != 0) ? 0 : -1;
}
static int SDL_RWopsCloseFree(SDL_RWops *ops)
{
int result = SDL_RWopsClose(ops);
SDL_FreeRW(ops);
return result;
}
const Uint32 SDL_RWOPS_PHYSFS = SDL_RWOPS_UNKNOWN+10;
void FileSystem::openRead(SDL_RWops &ops, void FileSystem::openRead(SDL_RWops &ops,
const char *filename, const char *filename,
FileType type, FileType type,
@ -846,18 +919,17 @@ void FileSystem::openRead(SDL_RWops &ops,
{ {
PHYSFS_File *handle = p->openReadHandle(filename, type, foundExt); PHYSFS_File *handle = p->openReadHandle(filename, type, foundExt);
ops.size = SDL_RWopsSize; p->initReadOps(handle, ops, freeOnClose);
ops.seek = SDL_RWopsSeek; }
ops.read = SDL_RWopsRead;
ops.write = SDL_RWopsWrite;
if (freeOnClose) void FileSystem::openReadRaw(SDL_RWops &ops,
ops.close = SDL_RWopsCloseFree; const char *filename,
else bool freeOnClose)
ops.close = SDL_RWopsClose; {
PHYSFS_File *handle = PHYSFS_openRead(filename);
assert(handle);
ops.type = SDL_RWOPS_PHYSFS; p->initReadOps(handle, ops, freeOnClose);
ops.hidden.unknown.data1 = handle;
} }
bool FileSystem::exists(const char *filename, FileType type) bool FileSystem::exists(const char *filename, FileType type)

View File

@ -25,6 +25,7 @@
#include <SDL_rwops.h> #include <SDL_rwops.h>
struct FileSystemPrivate; struct FileSystemPrivate;
struct SharedFontState;
class FileSystem class FileSystem
{ {
@ -35,9 +36,13 @@ public:
void addPath(const char *path); void addPath(const char *path);
/* Call this after the last 'addPath()' */ /* Call these after the last 'addPath()' */
void createPathCache(); void createPathCache();
/* Scans "Fonts/" and creates inventory of
* available font assets */
void initFontSets(SharedFontState &sfs);
/* For extension supplementing */ /* For extension supplementing */
enum FileType enum FileType
{ {
@ -53,6 +58,11 @@ public:
bool freeOnClose = false, bool freeOnClose = false,
const char **foundExt = 0); const char **foundExt = 0);
/* Circumvents extension supplementing */
void openReadRaw(SDL_RWops &ops,
const char *filename,
bool freeOnClose = false);
bool exists(const char *filename, bool exists(const char *filename,
FileType type = Undefined); FileType type = Undefined);

View File

@ -26,6 +26,7 @@
#include "exception.h" #include "exception.h"
#include "boost-hash.h" #include "boost-hash.h"
#include "util.h" #include "util.h"
#include "config.h"
#include <string> #include <string>
#include <utility> #include <utility>
@ -45,88 +46,151 @@
typedef std::pair<std::string, int> FontKey; typedef std::pair<std::string, int> FontKey;
static void strToLower(std::string &str)
{
for (size_t i = 0; i < str.size(); ++i)
str[i] = tolower(str[i]);
}
struct FontPoolPrivate
{
BoostHash<FontKey, TTF_Font*> hash;
};
FontPool::FontPool()
{
p = new FontPoolPrivate;
}
FontPool::~FontPool()
{
BoostHash<FontKey, TTF_Font*>::const_iterator iter;
for (iter = p->hash.cbegin(); iter != p->hash.cend(); ++iter)
TTF_CloseFont(iter->second);
delete p;
}
static SDL_RWops *openBundledFont() static SDL_RWops *openBundledFont()
{ {
return SDL_RWFromConstMem(BNDL_F_D(BUNDLED_FONT), BNDL_F_L(BUNDLED_FONT)); return SDL_RWFromConstMem(BNDL_F_D(BUNDLED_FONT), BNDL_F_L(BUNDLED_FONT));
} }
_TTF_Font *FontPool::request(const char *filename, struct FontSet
int size)
{ {
// FIXME Find out how font path resolution is done in VX/Ace /* 'Regular' style */
std::string nameKey(filename); std::string regular;
strToLower(nameKey);
strReplace(nameKey, ' ', '_');
bool useBundled = false; /* Any other styles (used in case no 'Regular' exists) */
std::string path = std::string("Fonts/") + nameKey; std::string other;
if (!shState->fileSystem().exists(path.c_str(), FileSystem::Font)) };
struct SharedFontStatePrivate
{ {
/* Use the same name key for the bundled font /* Maps: font family name, To: substituted family name,
* even when it resulted from multiple different * as specified via configuration file / arguments */
* font name requests. The space at the front is BoostHash<std::string, std::string> subs;
* to prevent collisions (spaces are normally
* replaced with '_' */ /* Maps: font family name, To: set of physical
useBundled = true; * font filenames located in "Fonts/" */
nameKey = " bundled"; BoostHash<std::string, FontSet> sets;
/* Pool of already opened fonts; once opened, they are reused
* and never closed until the termination of the program */
BoostHash<FontKey, TTF_Font*> pool;
};
SharedFontState::SharedFontState(const Config &conf)
{
p = new SharedFontStatePrivate;
/* Parse font substitutions */
for (size_t i = 0; i < conf.fontSubs.size(); ++i)
{
const std::string &raw = conf.fontSubs[i];
size_t sepPos = raw.find_first_of('>');
if (sepPos == std::string::npos)
continue;
std::string from = raw.substr(0, sepPos);
std::string to = raw.substr(sepPos+1);
p->subs.insert(from, to);
}
} }
FontKey key(nameKey, size); SharedFontState::~SharedFontState()
{
BoostHash<FontKey, TTF_Font*>::const_iterator iter;
for (iter = p->pool.cbegin(); iter != p->pool.cend(); ++iter)
TTF_CloseFont(iter->second);
TTF_Font *font = p->hash.value(key, 0); delete p;
}
void SharedFontState::initFontSetCB(SDL_RWops &ops,
const std::string &filename)
{
TTF_Font *font = TTF_OpenFontRW(&ops, 0, 0);
if (!font)
return;
std::string family = TTF_FontFaceFamilyName(font);
std::string style = TTF_FontFaceStyleName(font);
TTF_CloseFont(font);
FontSet &set = p->sets[family];
if (style == "Regular")
set.regular = filename;
else
set.other = filename;
}
_TTF_Font *SharedFontState::getFont(std::string family,
int size)
{
/* Check for substitutions */
if (p->subs.contains(family))
family = p->subs[family];
/* Find out if the font asset exists */
const FontSet &req = p->sets[family];
if (req.regular.empty() && req.other.empty())
{
/* Doesn't exist; use built-in font */
family = "";
}
FontKey key(family, size);
TTF_Font *font = p->pool.value(key);
if (font) if (font)
return font; return font;
/* Not in hash, open */ /* Not in pool; open new handle */
SDL_RWops *ops; SDL_RWops *ops;
if (useBundled) if (family.empty())
{ {
/* Built-in font */
ops = openBundledFont(); ops = openBundledFont();
} }
else else
{ {
/* Use 'other' path as alternative in case
* we have no 'regular' styled font asset */
const char *path = !req.regular.empty()
? req.regular.c_str() : req.other.c_str();
ops = SDL_AllocRW(); ops = SDL_AllocRW();
shState->fileSystem().openRead(*ops, path.c_str(), FileSystem::Font, true); shState->fileSystem().openReadRaw(*ops, path, true);
} }
// FIXME 0.9 is guesswork at this point // FIXME 0.9 is guesswork at this point
font = TTF_OpenFontRW(ops, 1, (float) size * .90); // float gamma = (96.0/45.0)*(5.0/14.0)*(size-5);
// font = TTF_OpenFontRW(ops, 1, gamma /** .90*/);
font = TTF_OpenFontRW(ops, 1, size* .90);
if (!font) if (!font)
throw Exception(Exception::SDLError, "SDL: %s", SDL_GetError()); throw Exception(Exception::SDLError, "%s", SDL_GetError());
p->hash.insert(key, font); p->pool.insert(key, font);
return font; return font;
} }
bool SharedFontState::fontPresent(std::string family)
{
/* Check for substitutions */
if (p->subs.contains(family))
family = p->subs[family];
const FontSet &set = p->sets[family];
return !(set.regular.empty() && set.other.empty());
}
struct FontPrivate struct FontPrivate
{ {
@ -183,9 +247,7 @@ Color FontPrivate::defaultColorTmp(255, 255, 255, 255);
bool Font::doesExist(const char *name) bool Font::doesExist(const char *name)
{ {
std::string path = std::string("Fonts/") + std::string(name); return shState->fontState().fontPresent(name);
return shState->fileSystem().exists(path.c_str(), FileSystem::Font);
} }
Font::Font(const char *name, Font::Font(const char *name,
@ -223,6 +285,10 @@ void Font::setSize(int value)
if (p->size == value) if (p->size == value)
return; return;
/* Catch illegal values (according to RMXP) */
if (value < 6 || value > 96)
throw Exception(Exception::ArgumentError, "%s", "bad value for size");
p->size = value; p->size = value;
p->sdlFont = 0; p->sdlFont = 0;
} }
@ -253,7 +319,7 @@ void Font::setDefaultName(const char *value)
_TTF_Font *Font::getSdlFont() _TTF_Font *Font::getSdlFont()
{ {
if (!p->sdlFont) if (!p->sdlFont)
p->sdlFont = shState->fontPool().request(p->name.c_str(), p->sdlFont = shState->fontState().getFont(p->name.c_str(),
p->size); p->size);
int style = TTF_STYLE_NORMAL; int style = TTF_STYLE_NORMAL;

View File

@ -25,22 +25,50 @@
#include "etc.h" #include "etc.h"
#include "util.h" #include "util.h"
struct SDL_RWops;
struct _TTF_Font; struct _TTF_Font;
struct FontPoolPrivate; struct Config;
class FontPool struct SharedFontStatePrivate;
class SharedFontState
{ {
public: public:
FontPool(); SharedFontState(const Config &conf);
~FontPool(); ~SharedFontState();
_TTF_Font *request(const char *filename, /* Called from FileSystem during font cache initialization
* (when "Fonts/" is scanned for available assets).
* 'ops' is an opened handle to a possible font file,
* 'filename' is the corresponding path */
void initFontSetCB(SDL_RWops &ops,
const std::string &filename);
_TTF_Font *getFont(std::string family,
int size); int size);
bool fontPresent(std::string family);
private: private:
FontPoolPrivate *p; SharedFontStatePrivate *p;
}; };
/* Concerning Font::name/defaultName :
* In RGSS, this is not actually a string; any type of
* object is accepted, however anything but strings and
* arrays is ignored (and text drawing turns blank).
* Single strings are interpreted as font family names,
* and directly passed to the underlying C++ object;
* arrays however are searched for the first string
* object corresponding to a valid font family name,
* and rendering is done with that. In mkxp, we pass
* this first valid font family as the 'name' attribute
* back to the C++ object on assignment and object
* creation (in case Font.default_name is also an array).
* Invalid parameters (things other than strings or
* arrays not containing any valid family name) are
* passed back as "". */
struct FontPrivate; struct FontPrivate;
class Font class Font

View File

@ -67,8 +67,8 @@ struct SharedStatePrivate
ShaderSet shaders; ShaderSet shaders;
TexPool texPool; TexPool texPool;
FontPool fontPool;
SharedFontState fontState;
Font *defaultFont; Font *defaultFont;
TEX::ID globalTex; TEX::ID globalTex;
@ -90,6 +90,7 @@ struct SharedStatePrivate
rtData(*threadData), rtData(*threadData),
config(threadData->config), config(threadData->config),
graphics(threadData), graphics(threadData),
fontState(threadData->config),
stampCounter(0) stampCounter(0)
{ {
if (!config.gameFolder.empty()) if (!config.gameFolder.empty())
@ -121,6 +122,8 @@ struct SharedStatePrivate
if (config.pathCache) if (config.pathCache)
fileSystem.createPathCache(); fileSystem.createPathCache();
fileSystem.initFontSets(fontState);
globalTexW = 128; globalTexW = 128;
globalTexH = 64; globalTexH = 64;
@ -206,8 +209,8 @@ GSATT(Audio&, audio)
GSATT(GLState&, _glState) GSATT(GLState&, _glState)
GSATT(ShaderSet&, shaders) GSATT(ShaderSet&, shaders)
GSATT(TexPool&, texPool) GSATT(TexPool&, texPool)
GSATT(FontPool&, fontPool)
GSATT(Quad&, gpQuad) GSATT(Quad&, gpQuad)
GSATT(SharedFontState&, fontState)
void SharedState::setBindingData(void *data) void SharedState::setBindingData(void *data)
{ {

View File

@ -43,8 +43,8 @@ class Input;
class Audio; class Audio;
class GLState; class GLState;
class TexPool; class TexPool;
class FontPool;
class Font; class Font;
class SharedFontState;
struct GlobalIBO; struct GlobalIBO;
struct Config; struct Config;
struct Vec2i; struct Vec2i;
@ -74,8 +74,8 @@ struct SharedState
ShaderSet &shaders(); ShaderSet &shaders();
TexPool &texPool(); TexPool &texPool();
FontPool &fontPool();
SharedFontState &fontState();
Font &defaultFont(); Font &defaultFont();
sigc::signal<void> prepareDraw; sigc::signal<void> prepareDraw;

View File

@ -48,13 +48,6 @@ extern const StaticRect autotileRects[];
typedef std::vector<SVertex> SVVector; typedef std::vector<SVertex> SVVector;
typedef struct { SVVector v[4]; } TileVBuffer; typedef struct { SVVector v[4]; } TileVBuffer;
/* Check if [C]ontainer contains [V]alue */
template<typename C, typename V>
inline bool contains(const C &c, const V &v)
{
return std::find(c.begin(), c.end(), v) != c.end();
}
static const int tilesetW = 8 * 32; static const int tilesetW = 8 * 32;
static const int autotileW = 3 * 32; static const int autotileW = 3 * 32;
static const int autotileH = 4 * 32; static const int autotileH = 4 * 32;

View File

@ -24,6 +24,7 @@
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
#include <algorithm>
static inline int static inline int
wrapRange(int value, int min, int max) wrapRange(int value, int min, int max)
@ -93,6 +94,13 @@ inline void strReplace(std::string &str,
str[i] = after; str[i] = after;
} }
/* Check if [C]ontainer contains [V]alue */
template<typename C, typename V>
inline bool contains(const C &c, const V &v)
{
return std::find(c.begin(), c.end(), v) != c.end();
}
#define ARRAY_SIZE(obj) (sizeof(obj) / sizeof((obj)[0])) #define ARRAY_SIZE(obj) (sizeof(obj) / sizeof((obj)[0]))
#define elementsN(obj) const int obj##N = ARRAY_SIZE(obj) #define elementsN(obj) const int obj##N = ARRAY_SIZE(obj)