mirror of
https://github.com/ciphervance/supercell-wx.git
synced 2025-10-30 16:20:06 +00:00
Scalable fonts using freetype-gl
This commit is contained in:
Dan Paulat
parent
ec8e2643ff
commit
289ed430c7
8 changed files with 400 additions and 181 deletions
|
|
@ -4,10 +4,16 @@
|
|||
#include <unordered_map>
|
||||
|
||||
#include <boost/log/trivial.hpp>
|
||||
#include <ft2build.h>
|
||||
#include <boost/timer/timer.hpp>
|
||||
#include <QFile>
|
||||
|
||||
#include FT_FREETYPE_H
|
||||
// #include <freetype-gl.h> (exclude opengl.h)
|
||||
#include <platform.h>
|
||||
#include <vec234.h>
|
||||
#include <vector.h>
|
||||
#include <texture-atlas.h>
|
||||
#include <texture-font.h>
|
||||
#include <ftgl-utils.h>
|
||||
|
||||
namespace scwx
|
||||
{
|
||||
|
|
@ -16,106 +22,237 @@ namespace qt
|
|||
namespace util
|
||||
{
|
||||
|
||||
struct TextureGlyph
|
||||
{
|
||||
int offsetX_;
|
||||
int offsetY_;
|
||||
int width_;
|
||||
int height_;
|
||||
float s0_;
|
||||
float t0_;
|
||||
float s1_;
|
||||
float t1_;
|
||||
float advanceX_;
|
||||
|
||||
TextureGlyph(int offsetX,
|
||||
int offsetY,
|
||||
int width,
|
||||
int height,
|
||||
float s0,
|
||||
float t0,
|
||||
float s1,
|
||||
float t1,
|
||||
float advanceX) :
|
||||
offsetX_ {offsetX},
|
||||
offsetY_ {offsetY},
|
||||
width_ {width},
|
||||
height_ {height},
|
||||
s0_ {s0},
|
||||
t0_ {t0},
|
||||
s1_ {s1},
|
||||
t1_ {t1},
|
||||
advanceX_ {advanceX}
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
static const std::string CODEPOINTS =
|
||||
" !\"#$%&'()*+,-./0123456789:;<=>?"
|
||||
"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
|
||||
"`abcdefghijklmnopqrstuvwxyz{|}~";
|
||||
|
||||
static const std::string logPrefix_ = "[scwx::qt::util::font] ";
|
||||
|
||||
static std::unordered_map<std::string, std::shared_ptr<Font>> fontMap_;
|
||||
|
||||
static FT_Library ft_ {nullptr};
|
||||
static std::mutex ftMutex_;
|
||||
class FontBuffer
|
||||
{
|
||||
public:
|
||||
explicit FontBuffer() :
|
||||
vaoId_ {GL_INVALID_INDEX},
|
||||
verticesId_ {GL_INVALID_INDEX},
|
||||
indicesId_ {GL_INVALID_INDEX},
|
||||
gpuISize_ {0},
|
||||
gpuVSize_ {0},
|
||||
dirty_ {true}
|
||||
{
|
||||
}
|
||||
|
||||
static bool InitializeFreeType();
|
||||
~FontBuffer() {}
|
||||
|
||||
GLuint vaoId_ = GL_INVALID_INDEX;
|
||||
GLuint verticesId_ = GL_INVALID_INDEX;
|
||||
GLuint indicesId_ = GL_INVALID_INDEX;
|
||||
GLsizei gpuISize_ = 0;
|
||||
GLsizei gpuVSize_ = 0;
|
||||
bool dirty_ = true;
|
||||
|
||||
std::vector<GLfloat> vertices_;
|
||||
std::vector<GLuint> indices_;
|
||||
|
||||
std::mutex mutex_;
|
||||
};
|
||||
|
||||
class FontImpl
|
||||
{
|
||||
public:
|
||||
explicit FontImpl(const std::string& resource) :
|
||||
resource_(resource), fontData_(), face_ {nullptr}
|
||||
resource_(resource), atlas_ {nullptr}
|
||||
{
|
||||
}
|
||||
|
||||
~FontImpl() {}
|
||||
~FontImpl()
|
||||
{
|
||||
if (atlas_ != nullptr)
|
||||
{
|
||||
ftgl::texture_atlas_delete(atlas_);
|
||||
}
|
||||
}
|
||||
|
||||
const std::string resource_;
|
||||
|
||||
QByteArray fontData_;
|
||||
FT_Face face_;
|
||||
ftgl::texture_atlas_t* atlas_;
|
||||
std::unordered_map<char, TextureGlyph> glyphs_;
|
||||
};
|
||||
|
||||
Font::Font(const std::string& resource) :
|
||||
p(std::make_unique<FontImpl>(resource))
|
||||
{
|
||||
}
|
||||
Font::~Font()
|
||||
Font::~Font() = default;
|
||||
|
||||
float Font::BufferText(std::shared_ptr<FontBuffer> buffer,
|
||||
const std::string& text,
|
||||
float x,
|
||||
float y,
|
||||
float scale,
|
||||
boost::gil::rgba8_pixel_t color) const
|
||||
{
|
||||
FT_Done_Face(p->face_);
|
||||
static constexpr float colorScale = 1.0f / 255.0f;
|
||||
|
||||
float r = color[0] * colorScale;
|
||||
float g = color[1] * colorScale;
|
||||
float b = color[2] * colorScale;
|
||||
float a = color[3] * colorScale;
|
||||
|
||||
for (size_t i = 0; i < text.length(); ++i)
|
||||
{
|
||||
const char& c = text[i];
|
||||
|
||||
auto it = p->glyphs_.find(c);
|
||||
if (it == p->glyphs_.end())
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(info)
|
||||
<< logPrefix_
|
||||
<< "Could not draw character: " << static_cast<uint32_t>(c);
|
||||
continue;
|
||||
}
|
||||
|
||||
TextureGlyph& glyph = it->second;
|
||||
|
||||
if (i > 0)
|
||||
{
|
||||
x += Kerning(text[i - 1], c) * scale;
|
||||
}
|
||||
|
||||
float x0 = x + glyph.offsetX_ * scale;
|
||||
float y0 = y + glyph.offsetY_ * scale;
|
||||
float x1 = x0 + glyph.width_ * scale;
|
||||
float y1 = y0 - glyph.height_ * scale;
|
||||
|
||||
float s0 = glyph.s0_;
|
||||
float t0 = glyph.t0_;
|
||||
float s1 = glyph.s1_;
|
||||
float t1 = glyph.t1_;
|
||||
|
||||
{
|
||||
std::scoped_lock lock(buffer->mutex_);
|
||||
|
||||
const GLuint i0 = static_cast<GLuint>(buffer->vertices_.size() / 9u);
|
||||
const GLuint i1 = i0 + 1;
|
||||
const GLuint i2 = i1 + 1;
|
||||
const GLuint i3 = i2 + 1;
|
||||
|
||||
buffer->indices_.insert(buffer->indices_.end(),
|
||||
{i0, i1, i2, i0, i2, i3});
|
||||
buffer->vertices_.insert(buffer->vertices_.end(),
|
||||
{x0, y0, 0, s0, t0, r, g, b, a, //
|
||||
x0, y1, 0, s0, t1, r, g, b, a, //
|
||||
x1, y1, 0, s1, t1, r, g, b, a, //
|
||||
x1, y0, 0, s1, t0, r, g, b, a});
|
||||
}
|
||||
|
||||
x += glyph.advanceX_ * scale;
|
||||
}
|
||||
|
||||
buffer->dirty_ = true;
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
void Font::GenerateGlyphs(OpenGLFunctions& gl,
|
||||
std::unordered_map<char, Glyph>& glyphs,
|
||||
unsigned int height)
|
||||
float Font::Kerning(char c1, char c2) const
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Face& face = p->face_;
|
||||
// TODO
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
// Allow single-byte texture colors
|
||||
gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
float Font::TextLength(const std::string& text, float scale) const
|
||||
{
|
||||
float x = 0.0f;
|
||||
|
||||
FT_Set_Pixel_Sizes(p->face_, 0, 48);
|
||||
|
||||
for (unsigned char c = 0; c < 128; c++)
|
||||
for (size_t i = 0; i < text.length(); ++i)
|
||||
{
|
||||
if (glyphs.find(c) != glyphs.end())
|
||||
const char& c = text[i];
|
||||
|
||||
auto it = p->glyphs_.find(c);
|
||||
if (it == p->glyphs_.end())
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(warning) << logPrefix_ << "Found glyph "
|
||||
<< static_cast<uint16_t>(c) << ", skipping";
|
||||
BOOST_LOG_TRIVIAL(info)
|
||||
<< logPrefix_
|
||||
<< "Character not found: " << static_cast<uint32_t>(c);
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((error = FT_Load_Char(face, c, FT_LOAD_RENDER)) != 0)
|
||||
TextureGlyph& glyph = it->second;
|
||||
|
||||
if (i > 0)
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(error) << logPrefix_ << "Failed to load glyph "
|
||||
<< static_cast<uint16_t>(c) << ": " << error;
|
||||
continue;
|
||||
x += Kerning(text[i - 1], c) * scale;
|
||||
}
|
||||
|
||||
GLuint texture;
|
||||
gl.glGenTextures(1, &texture);
|
||||
gl.glBindTexture(GL_TEXTURE_2D, texture);
|
||||
|
||||
gl.glTexImage2D(GL_TEXTURE_2D,
|
||||
0,
|
||||
GL_RED,
|
||||
face->glyph->bitmap.width,
|
||||
face->glyph->bitmap.rows,
|
||||
0,
|
||||
GL_RED,
|
||||
GL_UNSIGNED_BYTE,
|
||||
face->glyph->bitmap.buffer);
|
||||
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
|
||||
glyphs.insert(
|
||||
{c,
|
||||
Glyph {
|
||||
texture,
|
||||
glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),
|
||||
glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),
|
||||
face->glyph->advance.x}});
|
||||
x += glyph.advanceX_ * scale;
|
||||
}
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
GLuint Font::GenerateTexture(OpenGLFunctions& gl)
|
||||
{
|
||||
gl.glGenTextures(1, &p->atlas_->id);
|
||||
gl.glBindTexture(GL_TEXTURE_2D, p->atlas_->id);
|
||||
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
|
||||
gl.glTexImage2D(GL_TEXTURE_2D,
|
||||
0,
|
||||
GL_RED,
|
||||
static_cast<GLsizei>(p->atlas_->width),
|
||||
static_cast<GLsizei>(p->atlas_->height),
|
||||
0,
|
||||
GL_RED,
|
||||
GL_UNSIGNED_BYTE,
|
||||
p->atlas_->data);
|
||||
|
||||
return p->atlas_->id;
|
||||
}
|
||||
|
||||
std::shared_ptr<Font> Font::Create(const std::string& resource)
|
||||
{
|
||||
std::shared_ptr<Font> font = nullptr;
|
||||
FT_Error error;
|
||||
|
||||
if (!InitializeFreeType())
|
||||
{
|
||||
return font;
|
||||
}
|
||||
std::shared_ptr<Font> font = nullptr;
|
||||
boost::timer::cpu_timer timer;
|
||||
|
||||
auto it = fontMap_.find(resource);
|
||||
if (it != fontMap_.end())
|
||||
|
|
@ -132,24 +269,45 @@ std::shared_ptr<Font> Font::Create(const std::string& resource)
|
|||
return font;
|
||||
}
|
||||
|
||||
font = std::make_shared<Font>(resource);
|
||||
font->p->fontData_ = fontFile.readAll();
|
||||
font = std::make_shared<Font>(resource);
|
||||
QByteArray fontData = fontFile.readAll();
|
||||
|
||||
font->p->atlas_ = ftgl::texture_atlas_new(512, 512, 1);
|
||||
ftgl::texture_font_t* textureFont = ftgl::texture_font_new_from_memory(
|
||||
font->p->atlas_, 72, fontData.constData(), fontData.size());
|
||||
|
||||
textureFont->rendermode = ftgl::RENDER_SIGNED_DISTANCE_FIELD;
|
||||
|
||||
timer.start();
|
||||
texture_font_load_glyphs(textureFont, CODEPOINTS.c_str());
|
||||
timer.stop();
|
||||
|
||||
// Single-byte UTF-8 characters
|
||||
for (const char& c : CODEPOINTS)
|
||||
{
|
||||
std::scoped_lock(ftMutex_);
|
||||
if ((error = FT_New_Memory_Face(
|
||||
ft_,
|
||||
reinterpret_cast<const FT_Byte*>(font->p->fontData_.data()),
|
||||
font->p->fontData_.size(),
|
||||
0,
|
||||
&font->p->face_)) != 0)
|
||||
const ftgl::texture_glyph_t* glyph =
|
||||
ftgl::texture_font_get_glyph(textureFont, &c);
|
||||
|
||||
if (glyph != nullptr)
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(error)
|
||||
<< logPrefix_ << "Failed to load font: " << error;
|
||||
font.reset();
|
||||
font->p->glyphs_.emplace(c,
|
||||
TextureGlyph(glyph->offset_x,
|
||||
glyph->offset_y,
|
||||
static_cast<int>(glyph->width),
|
||||
static_cast<int>(glyph->height),
|
||||
glyph->s0,
|
||||
glyph->t0,
|
||||
glyph->s1,
|
||||
glyph->t1,
|
||||
glyph->advance_x));
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_LOG_TRIVIAL(debug) << logPrefix_ << "Font \"" << resource
|
||||
<< "\" loaded in " << timer.format(6, "%ws");
|
||||
|
||||
texture_font_delete(textureFont);
|
||||
|
||||
if (font != nullptr)
|
||||
{
|
||||
fontMap_.insert({resource, font});
|
||||
|
|
@ -158,20 +316,127 @@ std::shared_ptr<Font> Font::Create(const std::string& resource)
|
|||
return font;
|
||||
}
|
||||
|
||||
static bool InitializeFreeType()
|
||||
std::shared_ptr<FontBuffer> Font::CreateBuffer()
|
||||
{
|
||||
std::scoped_lock(ftMutex_);
|
||||
return std::make_shared<FontBuffer>();
|
||||
}
|
||||
|
||||
FT_Error error;
|
||||
|
||||
if (ft_ == nullptr && (error = FT_Init_FreeType(&ft_)) != 0)
|
||||
void Font::ClearBuffer(std::shared_ptr<FontBuffer> buffer)
|
||||
{
|
||||
if (buffer != nullptr)
|
||||
{
|
||||
BOOST_LOG_TRIVIAL(error)
|
||||
<< logPrefix_ << "Could not init FreeType library: " << error;
|
||||
ft_ = nullptr;
|
||||
std::scoped_lock lock(buffer->mutex_);
|
||||
buffer->indices_.clear();
|
||||
buffer->vertices_.clear();
|
||||
buffer->dirty_ = true;
|
||||
}
|
||||
}
|
||||
|
||||
void Font::RenderBuffer(OpenGLFunctions& gl, std::shared_ptr<FontBuffer> buffer)
|
||||
{
|
||||
// TODO:
|
||||
if (buffer == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
return (ft_ != nullptr);
|
||||
std::scoped_lock lock(buffer->mutex_);
|
||||
|
||||
// TODO: Vertex buffer upload
|
||||
if (buffer->dirty_)
|
||||
{
|
||||
if (buffer->verticesId_ == GL_INVALID_INDEX)
|
||||
{
|
||||
gl.glGenBuffers(1, &buffer->verticesId_);
|
||||
}
|
||||
if (buffer->indicesId_ == GL_INVALID_INDEX)
|
||||
{
|
||||
gl.glGenBuffers(1, &buffer->indicesId_);
|
||||
}
|
||||
|
||||
GLsizei vSize =
|
||||
static_cast<GLsizei>(buffer->vertices_.size() * sizeof(GLfloat));
|
||||
GLsizei iSize =
|
||||
static_cast<GLsizei>(buffer->indices_.size() * sizeof(GLuint));
|
||||
|
||||
// Always upload vertices first to avoid rendering non-existent data
|
||||
|
||||
// Upload vertices
|
||||
gl.glBindBuffer(GL_ARRAY_BUFFER, buffer->verticesId_);
|
||||
if (vSize != buffer->gpuVSize_)
|
||||
{
|
||||
gl.glBufferData(
|
||||
GL_ARRAY_BUFFER, vSize, buffer->vertices_.data(), GL_DYNAMIC_DRAW);
|
||||
buffer->gpuVSize_ = vSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
gl.glBufferSubData(
|
||||
GL_ARRAY_BUFFER, 0, vSize, buffer->vertices_.data());
|
||||
}
|
||||
|
||||
// Upload indices
|
||||
gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer->indicesId_);
|
||||
if (iSize != buffer->gpuISize_)
|
||||
{
|
||||
gl.glBufferData(GL_ELEMENT_ARRAY_BUFFER,
|
||||
iSize,
|
||||
buffer->indices_.data(),
|
||||
GL_DYNAMIC_DRAW);
|
||||
}
|
||||
else
|
||||
{
|
||||
gl.glBufferSubData(
|
||||
GL_ELEMENT_ARRAY_BUFFER, 0, iSize, buffer->indices_.data());
|
||||
}
|
||||
|
||||
buffer->dirty_ = false;
|
||||
}
|
||||
|
||||
// TODO: Setup
|
||||
if (buffer->vaoId_ == GL_INVALID_INDEX)
|
||||
{
|
||||
// Generate and setup VAO
|
||||
gl.glGenVertexArrays(1, &buffer->vaoId_);
|
||||
gl.glBindVertexArray(buffer->vaoId_);
|
||||
|
||||
gl.glBindBuffer(GL_ARRAY_BUFFER, buffer->verticesId_);
|
||||
|
||||
// vec3 aVertex
|
||||
gl.glEnableVertexAttribArray(0);
|
||||
gl.glVertexAttribPointer(
|
||||
0, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), nullptr);
|
||||
|
||||
// vec2 aTexCoords
|
||||
gl.glEnableVertexAttribArray(1);
|
||||
gl.glVertexAttribPointer(
|
||||
1,
|
||||
2,
|
||||
GL_FLOAT,
|
||||
GL_FALSE,
|
||||
9 * sizeof(float),
|
||||
reinterpret_cast<const GLvoid*>(3 * sizeof(float)));
|
||||
|
||||
// vec4 aColor
|
||||
gl.glEnableVertexAttribArray(2);
|
||||
gl.glVertexAttribPointer(
|
||||
2,
|
||||
4,
|
||||
GL_FLOAT,
|
||||
GL_FALSE,
|
||||
9 * sizeof(float),
|
||||
reinterpret_cast<const GLvoid*>(5 * sizeof(float)));
|
||||
|
||||
gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer->indicesId_);
|
||||
}
|
||||
|
||||
// Bind VAO for drawing
|
||||
gl.glBindVertexArray(buffer->vaoId_);
|
||||
|
||||
gl.glDrawElements(GL_TRIANGLES,
|
||||
static_cast<GLsizei>(buffer->indices_.size()),
|
||||
GL_UNSIGNED_INT,
|
||||
0);
|
||||
}
|
||||
|
||||
} // namespace util
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue