mirror of
https://github.com/rwengine/openrw.git
synced 2024-09-15 06:52:34 +02:00
273 lines
9.7 KiB
C++
273 lines
9.7 KiB
C++
#include <fonts/FontMapGta3.hpp>
|
|
#include <fonts/Unicode.hpp>
|
|
#include <rw/filesystem.hpp>
|
|
|
|
#include <ft2build.h>
|
|
#include FT_FREETYPE_H
|
|
|
|
#include <boost/program_options.hpp>
|
|
|
|
#include <QImage>
|
|
#include <QImageWriter>
|
|
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
const char *ft_error_to_string(int error) {
|
|
switch (error) {
|
|
#define FT_NOERRORDEF_(_DC, CODE, STR) case CODE: return STR;
|
|
#define FT_ERRORDEF_(_DC, CODE, STR) case CODE: return STR;
|
|
#include FT_ERROR_DEFINITIONS_H
|
|
#undef FT_ERRORDEF_
|
|
#undef FT_NOERRORDEF_
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
[[noreturn]]
|
|
void ft_error(int code)
|
|
{
|
|
std::cerr << ft_error_to_string(code) << "\n";
|
|
exit(1);
|
|
}
|
|
|
|
class FontTextureBuffer {
|
|
public:
|
|
FontTextureBuffer(unsigned fontsize, unsigned width, unsigned height, float height_width_ratio)
|
|
: m_texture{static_cast<int>(width), static_cast<int>(height), QImage::Format_ARGB32} {
|
|
m_aspectratio = height_width_ratio;
|
|
m_fontsize = fontsize;
|
|
m_glyph_width = width / 16;
|
|
m_glyph_height = height_width_ratio * m_glyph_width;
|
|
|
|
int error = FT_Init_FreeType(&m_library);
|
|
if (error) ft_error(error);
|
|
}
|
|
|
|
~FontTextureBuffer() {
|
|
for (auto face : m_faces) {
|
|
int error = FT_Done_Face(face);
|
|
if (error) ft_error(error);
|
|
}
|
|
int error = FT_Done_FreeType(m_library);
|
|
if (error) ft_error(error);
|
|
}
|
|
|
|
void clear() {
|
|
m_texture.fill(QColor{0, 0, 0, 0});
|
|
m_advances.clear();
|
|
}
|
|
|
|
void add_face(const char *path) {
|
|
m_faces.emplace_back();
|
|
FT_Face &face = m_faces.back();
|
|
int error = FT_New_Face(m_library, path, 0, &face);
|
|
if (error) ft_error(error);
|
|
error = FT_Select_Charmap(face, FT_ENCODING_UNICODE);
|
|
if (error) ft_error(error);
|
|
error = FT_Set_Pixel_Sizes(face, 0, m_fontsize);
|
|
if (error) ft_error(error);
|
|
}
|
|
|
|
void draw_glyph_mono(int index, FT_GlyphSlot glyph) {
|
|
int x = index % 16;
|
|
int y = index / 16 - 2;
|
|
QPoint topleft = {x * static_cast<int>(m_glyph_width), y * static_cast<int>(m_glyph_height)};
|
|
QPoint baselineleft = topleft + QPoint{0, static_cast<int>(m_glyph_width)};
|
|
|
|
if (baselineleft.x() + glyph->metrics.horiBearingX / 64 + glyph->metrics.width / 64 >= topleft.x() + m_glyph_width) {
|
|
std::cerr << "index " << index << " crosses right border\n";
|
|
}
|
|
if (baselineleft.y() - glyph->metrics.horiBearingY / 64 < topleft.y()) {
|
|
std::cerr << "index " << index << " crosses top border\n";
|
|
}
|
|
if (baselineleft.y() - glyph->metrics.horiBearingY / 64 + glyph->metrics.height / 64 >= topleft.y() + m_glyph_height) {
|
|
std::cerr << "index " << index << " crosses bottom border\n";
|
|
}
|
|
|
|
for (unsigned row = 0; row < glyph->bitmap.rows; ++row) {
|
|
const unsigned char *buffer = glyph->bitmap.buffer + row * glyph->bitmap.pitch;
|
|
for (unsigned i = 0; i < glyph->bitmap.width; ++i) {
|
|
bool pixel = (buffer[i/8] << (i % 8)) & 0x80;
|
|
QPoint point = baselineleft + QPoint{static_cast<int>(i), static_cast<int>(row - (glyph->metrics.horiBearingY / 64))};
|
|
QColor color{255, 255, 255, pixel ? 255 : 0};
|
|
m_texture.setPixelColor(point, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
void draw_glyph_normal(int index, FT_GlyphSlot glyph) {
|
|
int x = index % 16;
|
|
int y = index / 16 - 2;
|
|
QPoint topleft = {x * static_cast<int>(m_glyph_width), y * static_cast<int>(m_glyph_height)};
|
|
QPoint baselineleft = topleft + QPoint{0, 4 * static_cast<int>(m_glyph_height) / 5};
|
|
|
|
if (baselineleft.x() + glyph->metrics.horiBearingX / 64 + glyph->metrics.width / 64 >= topleft.x() + m_glyph_width) {
|
|
std::cerr << "index " << index << " crosses right border\n";
|
|
}
|
|
if (baselineleft.y() - glyph->metrics.horiBearingY / 64 < topleft.y()) {
|
|
std::cerr << "index " << index << " crosses top border\n";
|
|
}
|
|
if (baselineleft.y() - glyph->metrics.horiBearingY / 64 + glyph->metrics.height / 64 >= topleft.y() + m_glyph_height) {
|
|
std::cerr << "index " << index << " crosses bottom border\n";
|
|
}
|
|
|
|
for (unsigned row = 0; row < glyph->bitmap.rows; ++row) {
|
|
const unsigned char *buffer = glyph->bitmap.buffer + row * glyph->bitmap.pitch;
|
|
for (unsigned i = 0; i < glyph->bitmap.width; ++i) {
|
|
QPoint point = baselineleft + QPoint{static_cast<int>(i), static_cast<int>(row - (glyph->metrics.horiBearingY / 64))};
|
|
QColor color{255, 255, 255, buffer[i]};
|
|
m_texture.setPixelColor(point, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
enum RenderMode {
|
|
MONO,
|
|
NORMAL
|
|
};
|
|
|
|
void create_font_map(const FontMap &fontmap, RenderMode mode) {
|
|
GameStringChar next = 0x20;
|
|
FT_Render_Mode render_mode;
|
|
switch (mode) {
|
|
case RenderMode::MONO:
|
|
render_mode = FT_RENDER_MODE_MONO;
|
|
break;
|
|
default:
|
|
case RenderMode::NORMAL:
|
|
render_mode = FT_RENDER_MODE_NORMAL;
|
|
break;
|
|
}
|
|
for (auto it = fontmap.to_unicode_begin(); it != fontmap.to_unicode_end(); ++it) {
|
|
while (it->first != next) {
|
|
m_advances.push_back(0);
|
|
++next;
|
|
}
|
|
for (auto face : m_faces) {
|
|
auto glyph_index = FT_Get_Char_Index(face, it->second);
|
|
if (glyph_index == 0) {
|
|
continue;
|
|
}
|
|
int error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
|
|
if (error) ft_error(error);
|
|
error = FT_Render_Glyph(face->glyph, render_mode);
|
|
if (error) ft_error(error);
|
|
|
|
switch (mode) {
|
|
case RenderMode::MONO:
|
|
draw_glyph_mono(it->first, face->glyph);
|
|
break;
|
|
case RenderMode::NORMAL:
|
|
draw_glyph_normal(it->first, face->glyph);
|
|
break;
|
|
}
|
|
|
|
int advance = face->glyph->metrics.horiAdvance / 64;// - face->glyph->metrics.horiBearingX / 64;
|
|
if (advance < 0 || advance > 255) {
|
|
std::cerr << "advance out of range\n";
|
|
}
|
|
m_advances.push_back(advance);
|
|
++next;
|
|
break;
|
|
}
|
|
if (it->first + 1 != next) {
|
|
std::cerr << "unknown character.\n"; exit(1);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void write(const rwfs::path &bitmap_path, const rwfs::path &advance_path) {
|
|
QImageWriter writer(QString::fromStdString(bitmap_path.string()));
|
|
writer.write(m_texture);
|
|
std::ofstream ofs(advance_path.string(), std::ios_base::out);
|
|
ofs << m_aspectratio << '\n';
|
|
for (auto adv : m_advances) {
|
|
ofs << int(adv) << '\n';
|
|
}
|
|
// ofs.write(reinterpret_cast<const char *>(m_advances.data()), m_advances.size());
|
|
}
|
|
|
|
private:
|
|
QImage m_texture;
|
|
|
|
float m_aspectratio;
|
|
unsigned m_fontsize;
|
|
unsigned m_glyph_width;
|
|
unsigned m_glyph_height;
|
|
FT_Library m_library;
|
|
|
|
std::vector<FT_Face> m_faces;
|
|
|
|
std::vector<std::uint8_t> m_advances;
|
|
};
|
|
|
|
int main(int argc, const char *argv[])
|
|
{
|
|
namespace po = boost::program_options;
|
|
po::options_description desc("Options");
|
|
desc.add_options()
|
|
("help", "Show this help message")
|
|
("fontsize,s", po::value<unsigned>()->value_name("FONTSIZE")->required(), "Fontsize")
|
|
("width,w", po::value<unsigned>()->value_name("WIDTH")->required(), "Width of the texture")
|
|
("height,h", po::value<unsigned>()->value_name("HEIGHT")->required(), "Height of the texture")
|
|
("ratio,r", po::value<float>()->value_name("ASPECTRATIO"), "Aspect ratio")
|
|
("map,m", po::value<unsigned>()->value_name("MAP")->required(), "Font map to use")
|
|
("font,f", po::value<std::vector<std::string>>()->value_name("PATH")->required(), "Path to fonts")
|
|
("texture,t", po::value<rwfs::path>()->value_name("PATH")->required(), "Output texture")
|
|
("advance,a", po::value<rwfs::path>()->value_name("PATH")->required(), "Output advances")
|
|
;
|
|
|
|
po::variables_map vm;
|
|
try {
|
|
po::store(po::parse_command_line(argc, argv, desc), vm);
|
|
if (vm.count("help")) {
|
|
std::cout << desc;
|
|
return EXIT_SUCCESS;
|
|
}
|
|
po::notify(vm);
|
|
} catch (po::error &ex) {
|
|
std::cerr << "Error parsing arguments: " << ex.what() << std::endl;
|
|
std::cerr << desc;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
const auto fontmap_index = vm["map"].as<unsigned>();
|
|
const auto width = vm["width"].as<unsigned>();
|
|
const auto height = vm["height"].as<unsigned>();
|
|
const auto fontsize = vm["fontsize"].as<unsigned>();
|
|
|
|
float aspect;
|
|
if (vm.count("aspect")) {
|
|
aspect = vm["aspect"].as<float>();
|
|
} else {
|
|
if (fontmap_index == 0) {
|
|
aspect = 1.0f;
|
|
} else {
|
|
aspect = 1.25f;
|
|
}
|
|
}
|
|
|
|
if (fontmap_index >= fontmaps_gta3_font.size()) {
|
|
std::cerr << "Illegal map: range: [0, " << fontmaps_gta3_font.size() << ")\n";
|
|
std::cerr << desc;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
FontTextureBuffer texBuffer{fontsize, width, height, aspect};
|
|
|
|
for (const auto &fontpath : vm["font"].as<std::vector<std::string>>()) {
|
|
texBuffer.add_face(fontpath.c_str());
|
|
}
|
|
|
|
texBuffer.create_font_map(fontmaps_gta3_font[fontmap_index], FontTextureBuffer::RenderMode::NORMAL);
|
|
|
|
texBuffer.write(vm["texture"].as<rwfs::path>(), vm["advance"].as<rwfs::path>());
|
|
return 0;
|
|
}
|