mirrors/SFML
1
0
Fork 0
mirror of https://github.com/SFML/SFML.git synced 2024-11-25 04:41:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fixed font glyphs always being 2 pixels larger than they are supposed to be in each dimension, fixed wrong underline offset with some fonts, offset underline and strike through by half of their thickness so their center is positioned correctly, changed glyph and font metrics to use floats instead of ints to support scaling better.

Browse Source
This commit is contained in:
binary1248 2014-08-28 03:39:26 +02:00
parent c36ea074d8
commit b27cbd5036
4 changed files with 58 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/SFML/Graphics/Font.hpp
View File

@ -181,7 +181,7 @@ public :
/// \return Kerning value for \a first and \a second, in pixels
///
////////////////////////////////////////////////////////////
int getKerning(Uint32 first, Uint32 second, unsigned int characterSize) const;
float getKerning(Uint32 first, Uint32 second, unsigned int characterSize) const;
////////////////////////////////////////////////////////////
/// \brief Get the line spacing
@ -194,7 +194,7 @@ public :
/// \return Line spacing, in pixels
///
////////////////////////////////////////////////////////////
int getLineSpacing(unsigned int characterSize) const;
float getLineSpacing(unsigned int characterSize) const;
////////////////////////////////////////////////////////////
/// \brief Get the position of the underline
@ -209,7 +209,7 @@ public :
/// \see getUnderlineThickness
///
////////////////////////////////////////////////////////////
int getUnderlinePosition(unsigned int characterSize) const;
float getUnderlinePosition(unsigned int characterSize) const;
////////////////////////////////////////////////////////////
/// \brief Get the thickness of the underline
@ -223,7 +223,7 @@ public :
/// \see getUnderlinePosition
///
////////////////////////////////////////////////////////////
int getUnderlineThickness(unsigned int characterSize) const;
float getUnderlineThickness(unsigned int characterSize) const;
////////////////////////////////////////////////////////////
/// \brief Retrieve the texture containing the loaded glyphs of a certain size

6
include/SFML/Graphics/Glyph.hpp
View File

@ -51,9 +51,9 @@ public :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
int advance; ///< Offset to move horizontically to the next character
IntRect bounds; ///< Bounding rectangle of the glyph, in coordinates relative to the baseline
IntRect textureRect; ///< Texture coordinates of the glyph inside the font's texture
float advance; ///< Offset to move horizontically to the next character
FloatRect bounds; ///< Bounding rectangle of the glyph, in coordinates relative to the baseline
IntRect textureRect; ///< Texture coordinates of the glyph inside the font's texture
};
} // namespace sf

67
src/SFML/Graphics/Font.cpp
View File

@ -314,11 +314,11 @@ const Glyph& Font::getGlyph(Uint32 codePoint, unsigned int characterSize, bool b
////////////////////////////////////////////////////////////
int Font::getKerning(Uint32 first, Uint32 second, unsigned int characterSize) const
float Font::getKerning(Uint32 first, Uint32 second, unsigned int characterSize) const
{
// Special case where first or second is 0 (null character)
if (first == 0 || second == 0)
return 0;
return 0.f;
FT_Face face = static_cast<FT_Face>(m_face);
@ -334,37 +334,37 @@ int Font::getKerning(Uint32 first, Uint32 second, unsigned int characterSize) co
// X advance is already in pixels for bitmap fonts
if (!FT_IS_SCALABLE(face))
return kerning.x;
return static_cast<float>(kerning.x);
// Return the X advance
return kerning.x >> 6;
return static_cast<float>(kerning.x) / static_cast<float>(1 << 6);
}
else
{
// Invalid font, or no kerning
return 0;
return 0.f;
}
}
////////////////////////////////////////////////////////////
int Font::getLineSpacing(unsigned int characterSize) const
float Font::getLineSpacing(unsigned int characterSize) const
{
FT_Face face = static_cast<FT_Face>(m_face);
if (face && setCurrentSize(characterSize))
{
return (face->size->metrics.height >> 6);
return static_cast<float>(face->size->metrics.height) / static_cast<float>(1 << 6);
}
else
{
return 0;
return 0.f;
}
}
////////////////////////////////////////////////////////////
int Font::getUnderlinePosition(unsigned int characterSize) const
float Font::getUnderlinePosition(unsigned int characterSize) const
{
FT_Face face = static_cast<FT_Face>(m_face);
@ -372,19 +372,19 @@ int Font::getUnderlinePosition(unsigned int characterSize) const
{
// Return a fixed position if font is a bitmap font
if (!FT_IS_SCALABLE(face))
return characterSize / 10;
return characterSize / 10.f;
return (FT_MulFix(face->underline_position, face->size->metrics.y_scale) >> 6);
return -static_cast<float>(FT_MulFix(face->underline_position, face->size->metrics.y_scale)) / static_cast<float>(1 << 6);
}
else
{
return 0;
return 0.f;
}
}
////////////////////////////////////////////////////////////
int Font::getUnderlineThickness(unsigned int characterSize) const
float Font::getUnderlineThickness(unsigned int characterSize) const
{
FT_Face face = static_cast<FT_Face>(m_face);
@ -392,13 +392,13 @@ int Font::getUnderlineThickness(unsigned int characterSize) const
{
// Return a fixed thickness if font is a bitmap font
if (!FT_IS_SCALABLE(face))
return characterSize / 14;
return characterSize / 14.f;
return (FT_MulFix(face->underline_thickness, face->size->metrics.y_scale) >> 6);
return static_cast<float>(FT_MulFix(face->underline_thickness, face->size->metrics.y_scale)) / static_cast<float>(1 << 6);
}
else
{
return 0;
return 0.f;
}
}
@ -501,8 +501,7 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
// Convert the glyph to a bitmap (i.e. rasterize it)
FT_Glyph_To_Bitmap(&glyphDesc, FT_RENDER_MODE_NORMAL, 0, 1);
FT_BitmapGlyph bitmapGlyph = (FT_BitmapGlyph)glyphDesc;
FT_Bitmap& bitmap = bitmapGlyph->bitmap;
FT_Bitmap& bitmap = reinterpret_cast<FT_BitmapGlyph>(glyphDesc)->bitmap;
// Apply bold if necessary -- fallback technique using bitmap (lower quality)
if (bold && !outline)
@ -511,17 +510,12 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
}
// Compute the glyph's advance offset
glyph.advance = glyphDesc->advance.x >> 16;
glyph.advance = static_cast<float>(face->glyph->metrics.horiAdvance) / static_cast<float>(1 << 6);
if (bold)
glyph.advance += weight >> 6;
glyph.advance += static_cast<float>(weight) / static_cast<float>(1 << 6);
int width = bitmap.width;
int height = bitmap.rows;
int ascender = face->size->metrics.ascender >> 6;
// Offset to make up for empty space between ascender and virtual top of the typeface
// Only applied to scalable fonts i.e. not to bitmap fonts
int offset = FT_IS_SCALABLE(face) ? (characterSize - ascender) : 0;
if ((width > 0) && (height > 0))
{
@ -535,11 +529,18 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
// Find a good position for the new glyph into the texture
glyph.textureRect = findGlyphRect(page, width + 2 * padding, height + 2 * padding);
// Make sure the texture data is positioned in the centre
// of the allocated texture rectangle
glyph.textureRect.left += padding;
glyph.textureRect.top += padding;
glyph.textureRect.width -= 2 * padding;
glyph.textureRect.height -= 2 * padding;
// Compute the glyph's bounding box
glyph.bounds.left = bitmapGlyph->left - padding;
glyph.bounds.top = -bitmapGlyph->top - padding - offset;
glyph.bounds.width = width + 2 * padding;
glyph.bounds.height = height + 2 * padding;
glyph.bounds.left = static_cast<float>(face->glyph->metrics.horiBearingX) / static_cast<float>(1 << 6);
glyph.bounds.top = -static_cast<float>(face->glyph->metrics.horiBearingY) / static_cast<float>(1 << 6);
glyph.bounds.width = static_cast<float>(face->glyph->metrics.width) / static_cast<float>(1 << 6);
glyph.bounds.height = static_cast<float>(face->glyph->metrics.height) / static_cast<float>(1 << 6);
// Extract the glyph's pixels from the bitmap
m_pixelBuffer.resize(width * height * 4, 255);
@ -574,10 +575,10 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
}
// Write the pixels to the texture
unsigned int x = glyph.textureRect.left + padding;
unsigned int y = glyph.textureRect.top + padding;
unsigned int w = glyph.textureRect.width - 2 * padding;
unsigned int h = glyph.textureRect.height - 2 * padding;
unsigned int x = glyph.textureRect.left;
unsigned int y = glyph.textureRect.top;
unsigned int w = glyph.textureRect.width;
unsigned int h = glyph.textureRect.height;
page.texture.update(&m_pixelBuffer[0], w, h, x, y);
}

33
src/SFML/Graphics/Text.cpp
View File

@ -28,6 +28,7 @@
#include <SFML/Graphics/Text.hpp>
#include <SFML/Graphics/Texture.hpp>
#include <SFML/Graphics/RenderTarget.hpp>
#include <cmath>
namespace sf
@ -262,14 +263,14 @@ void Text::ensureGeometryUpdate() const
bool underlined = (m_style & Underlined) != 0;
bool strikeThrough = (m_style & StrikeThrough) != 0;
float italic = (m_style & Italic) ? 0.208f : 0.f; // 12 degrees
float underlineOffset = static_cast<float>(m_font->getUnderlinePosition(m_characterSize));
float underlineThickness = static_cast<float>(m_font->getUnderlineThickness(m_characterSize));
float underlineOffset = m_font->getUnderlinePosition(m_characterSize);
float underlineThickness = m_font->getUnderlineThickness(m_characterSize);
// Compute the location of the strike through dynamically
// We use the center point of the lowercase 'x' glyph as the reference
// We reuse the underline thickness as the thickness of the strike through as well
IntRect xBounds = m_font->getGlyph(L'x', m_characterSize, bold).bounds;
float strikeThroughOffset = static_cast<float>(xBounds.top) + static_cast<float>(xBounds.height) / 2.f;
FloatRect xBounds = m_font->getGlyph(L'x', m_characterSize, bold).bounds;
float strikeThroughOffset = xBounds.top + xBounds.height / 2.f;
// Precompute the variables needed by the algorithm
float hspace = static_cast<float>(m_font->getGlyph(L' ', m_characterSize, bold).advance);
@ -294,8 +295,8 @@ void Text::ensureGeometryUpdate() const
// If we're using the underlined style and there's a new line, draw a line
if (underlined && (curChar == L'\n'))
{
float top = y + underlineOffset;
float bottom = top + underlineThickness;
float top = std::floor(y + underlineOffset - (underlineThickness / 2) + 0.5f);
float bottom = top + std::floor(underlineThickness + 0.5f);
m_vertices.append(Vertex(Vector2f(0, top), m_color, Vector2f(1, 1)));
m_vertices.append(Vertex(Vector2f(x, top), m_color, Vector2f(1, 1)));
@ -308,8 +309,8 @@ void Text::ensureGeometryUpdate() const
// If we're using the strike through style and there's a new line, draw a line across all characters
if (strikeThrough && (curChar == L'\n'))
{
float top = y + strikeThroughOffset;
float bottom = top + underlineThickness;
float top = std::floor(y + strikeThroughOffset - (underlineThickness / 2) + 0.5f);
float bottom = top + std::floor(underlineThickness + 0.5f);
m_vertices.append(Vertex(Vector2f(0, top), m_color, Vector2f(1, 1)));
m_vertices.append(Vertex(Vector2f(x, top), m_color, Vector2f(1, 1)));
@ -344,10 +345,10 @@ void Text::ensureGeometryUpdate() const
// Extract the current glyph's description
const Glyph& glyph = m_font->getGlyph(curChar, m_characterSize, bold);
int left = glyph.bounds.left;
int top = glyph.bounds.top;
int right = glyph.bounds.left + glyph.bounds.width;
int bottom = glyph.bounds.top + glyph.bounds.height;
float left = glyph.bounds.left;
float top = glyph.bounds.top;
float right = glyph.bounds.left + glyph.bounds.width;
float bottom = glyph.bounds.top + glyph.bounds.height;
float u1 = static_cast<float>(glyph.textureRect.left);
float v1 = static_cast<float>(glyph.textureRect.top);
@ -375,8 +376,8 @@ void Text::ensureGeometryUpdate() const
// If we're using the underlined style, add the last line
if (underlined)
{
float top = y + underlineOffset;
float bottom = top + underlineThickness;
float top = std::floor(y + underlineOffset - (underlineThickness / 2) + 0.5f);
float bottom = top + std::floor(underlineThickness + 0.5f);
m_vertices.append(Vertex(Vector2f(0, top), m_color, Vector2f(1, 1)));
m_vertices.append(Vertex(Vector2f(x, top), m_color, Vector2f(1, 1)));
@ -389,8 +390,8 @@ void Text::ensureGeometryUpdate() const
// If we're using the strike through style, add the last line across all characters
if (strikeThrough)
{
float top = y + strikeThroughOffset;
float bottom = top + underlineThickness;
float top = std::floor(y + strikeThroughOffset - (underlineThickness / 2) + 0.5f);
float bottom = top + std::floor(underlineThickness + 0.5f);
m_vertices.append(Vertex(Vector2f(0, top), m_color, Vector2f(1, 1)));
m_vertices.append(Vertex(Vector2f(x, top), m_color, Vector2f(1, 1)));