float lineLength,

float lineTop,

const sf::Color& color,

float offset,

float thickness,

float outlineThickness = 0)

{

const float top = std::floor(lineTop + offset - (thickness / 2) + 0.5f);

const float bottom = top + std::floor(thickness + 0.5f);

vertices.append({{-outlineThickness, top - outlineThickness}, color, {1.0f, 1.0f}});

vertices.append({{lineLength + outlineThickness, top - outlineThickness}, color, {1.0f, 1.0f}});

vertices.append({{-outlineThickness, bottom + outlineThickness}, color, {1.0f, 1.0f}});

vertices.append({{-outlineThickness, bottom + outlineThickness}, color, {1.0f, 1.0f}});

vertices.append({{lineLength + outlineThickness, top - outlineThickness}, color, {1.0f, 1.0f}});

vertices.append({{lineLength + outlineThickness, bottom + outlineThickness}, color, {1.0f, 1.0f}});

{

const sf::Vector2f padding(1.f, 1.f);

const sf::Vector2f p1 = glyph.bounds.position - padding;

const sf::Vector2f p2 = glyph.bounds.position + glyph.bounds.size + padding;

const auto uv1 = sf::Vector2f(glyph.textureRect.position) - padding;

const auto uv2 = sf::Vector2f(glyph.textureRect.position + glyph.textureRect.size) + padding;

vertices.append({position + sf::Vector2f(p1.x - italicShear * p1.y, p1.y), color, {uv1.x, uv1.y}});

vertices.append({position + sf::Vector2f(p2.x - italicShear * p1.y, p1.y), color, {uv2.x, uv1.y}});

vertices.append({position + sf::Vector2f(p1.x - italicShear * p2.y, p2.y), color, {uv1.x, uv2.y}});

vertices.append({position + sf::Vector2f(p1.x - italicShear * p2.y, p2.y), color, {uv1.x, uv2.y}});

vertices.append({position + sf::Vector2f(p2.x - italicShear * p1.y, p1.y), color, {uv2.x, uv1.y}});

vertices.append({position + sf::Vector2f(p2.x - italicShear * p2.y, p2.y), color, {uv2.x, uv2.y}});

m_string(std::move(string)),

m_font(&font),

m_characterSize(characterSize)

{

{

if (m_string != string)

{

m_string = string;

m_geometryNeedUpdate = true;

}

{

if (m_font != &font)

{

m_font = &font;

m_geometryNeedUpdate = true;

}

{

if (m_characterSize != size)

{

m_characterSize = size;

m_geometryNeedUpdate = true;

}

{

if (m_letterSpacingFactor != spacingFactor)

{

m_letterSpacingFactor = spacingFactor;

m_geometryNeedUpdate = true;

}

{

if (m_lineSpacingFactor != spacingFactor)

{

m_lineSpacingFactor = spacingFactor;

m_geometryNeedUpdate = true;

}

{

if (m_style != style)

{

m_style = style;

m_geometryNeedUpdate = true;

}

{

if (color != m_fillColor)

{

m_fillColor = color;

// Change vertex colors directly, no need to update whole geometry

// (if geometry is updated anyway, we can skip this step)

if (!m_geometryNeedUpdate)

{

for (std::size_t i = 0; i < m_vertices.getVertexCount(); ++i)

m_vertices[i].color = m_fillColor;

}

}

{

if (color != m_outlineColor)

{

m_outlineColor = color;

// Change vertex colors directly, no need to update whole geometry

// (if geometry is updated anyway, we can skip this step)

if (!m_geometryNeedUpdate)

{

for (std::size_t i = 0; i < m_outlineVertices.getVertexCount(); ++i)

m_outlineVertices[i].color = m_outlineColor;

}

}

{

if (thickness != m_outlineThickness)

{

m_outlineThickness = thickness;

m_geometryNeedUpdate = true;

}

{

// Adjust the index if it's out of range

index = std::min(index, m_string.getSize());

// Precompute the variables needed by the algorithm

const bool isBold = m_style & Bold;

float whitespaceWidth = m_font->getGlyph(U' ', m_characterSize, isBold).advance;

const float letterSpacing = (whitespaceWidth / 3.f) * (m_letterSpacingFactor - 1.f);

whitespaceWidth += letterSpacing;

const float lineSpacing = m_font->getLineSpacing(m_characterSize) * m_lineSpacingFactor;

// Compute the position

Vector2f position;

std::uint32_t prevChar = 0;

for (std::size_t i = 0; i < index; ++i)

{

const std::uint32_t curChar = m_string[i];

// Apply the kerning offset

position.x += m_font->getKerning(prevChar, curChar, m_characterSize, isBold);

prevChar = curChar;

// Handle special characters

switch (curChar)

{

case U' ':

position.x += whitespaceWidth;

continue;

case U'\t':

position.x += whitespaceWidth * 4;

continue;

case U'\n':

position.y += lineSpacing;

position.x = 0;

continue;

}

// For regular characters, add the advance offset of the glyph

position.x += m_font->getGlyph(curChar, m_characterSize, isBold).advance + letterSpacing;

}

// Transform the position to global coordinates

position = getTransform().transformPoint(position);

return position;

{

ensureGeometryUpdate();

return m_bounds;

{

ensureGeometryUpdate();

states.transform *= getTransform();

states.texture = &m_font->getTexture(m_characterSize);

states.coordinateType = CoordinateType::Pixels;

// Only draw the outline if there is something to draw

if (m_outlineThickness != 0)

target.draw(m_outlineVertices, states);

target.draw(m_vertices, states);

{

// Do nothing, if geometry has not changed and the font texture has not changed

if (!m_geometryNeedUpdate && m_font->getTexture(m_characterSize).m_cacheId == m_fontTextureId)

return;

// Save the current fonts texture id

m_fontTextureId = m_font->getTexture(m_characterSize).m_cacheId;

// Mark geometry as updated

m_geometryNeedUpdate = false;

// Clear the previous geometry

m_vertices.clear();

m_outlineVertices.clear();

m_bounds = FloatRect();

// No text: nothing to draw

if (m_string.isEmpty())

return;

// Compute values related to the text style

const bool isBold = m_style & Bold;

const bool isUnderlined = m_style & Underlined;

const bool isStrikeThrough = m_style & StrikeThrough;

const float italicShear = (m_style & Italic) ? degrees(12).asRadians() : 0.f;

const float underlineOffset = m_font->getUnderlinePosition(m_characterSize);

const 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

const float strikeThroughOffset = m_font->getGlyph(U'x', m_characterSize, isBold).bounds.getCenter().y;

// Precompute the variables needed by the algorithm

float whitespaceWidth = m_font->getGlyph(U' ', m_characterSize, isBold).advance;

const float letterSpacing = (whitespaceWidth / 3.f) * (m_letterSpacingFactor - 1.f);

whitespaceWidth += letterSpacing;

const float lineSpacing = m_font->getLineSpacing(m_characterSize) * m_lineSpacingFactor;

float x = 0.f;

auto y = static_cast<float>(m_characterSize);

// Create one quad for each character

auto minX = static_cast<float>(m_characterSize);

auto minY = static_cast<float>(m_characterSize);

float maxX = 0.f;

float maxY = 0.f;

std::uint32_t prevChar = 0;

for (const std::uint32_t curChar : m_string)

{

// Skip the \r char to avoid weird graphical issues

if (curChar == U'\r')

continue;

// Apply the kerning offset

x += m_font->getKerning(prevChar, curChar, m_characterSize, isBold);

// If we're using the underlined style and there's a new line, draw a line

if (isUnderlined && (curChar == U'\n' && prevChar != U'\n'))

{

addLine(m_vertices, x, y, m_fillColor, underlineOffset, underlineThickness);

if (m_outlineThickness != 0)

addLine(m_outlineVertices, x, y, m_outlineColor, underlineOffset, underlineThickness, m_outlineThickness);

}

// If we're using the strike through style and there's a new line, draw a line across all characters

if (isStrikeThrough && (curChar == U'\n' && prevChar != U'\n'))

{

addLine(m_vertices, x, y, m_fillColor, strikeThroughOffset, underlineThickness);

if (m_outlineThickness != 0)

addLine(m_outlineVertices, x, y, m_outlineColor, strikeThroughOffset, underlineThickness, m_outlineThickness);

}

prevChar = curChar;

// Handle special characters

if ((curChar == U' ') || (curChar == U'\n') || (curChar == U'\t'))

{

// Update the current bounds (min coordinates)

minX = std::min(minX, x);

minY = std::min(minY, y);

switch (curChar)

{

case U' ':

x += whitespaceWidth;

break;

case U'\t':

x += whitespaceWidth * 4;

break;

case U'\n':

y += lineSpacing;

x = 0;

break;

}

// Update the current bounds (max coordinates)

maxX = std::max(maxX, x);

maxY = std::max(maxY, y);

// Next glyph, no need to create a quad for whitespace

continue;

}

// Apply the outline

if (m_outlineThickness != 0)

{

const Glyph& glyph = m_font->getGlyph(curChar, m_characterSize, isBold, m_outlineThickness);

// Add the outline glyph to the vertices

addGlyphQuad(m_outlineVertices, Vector2f(x, y), m_outlineColor, glyph, italicShear);

}

// Extract the current glyph's description

const Glyph& glyph = m_font->getGlyph(curChar, m_characterSize, isBold);

// Add the glyph to the vertices

addGlyphQuad(m_vertices, Vector2f(x, y), m_fillColor, glyph, italicShear);

// Update the current bounds

const Vector2f p1 = glyph.bounds.position;

const Vector2f p2 = glyph.bounds.position + glyph.bounds.size;

minX = std::min(minX, x + p1.x - italicShear * p2.y);

maxX = std::max(maxX, x + p2.x - italicShear * p1.y);

minY = std::min(minY, y + p1.y);

maxY = std::max(maxY, y + p2.y);

// Advance to the next character

x += glyph.advance + letterSpacing;

}

// If we're using outline, update the current bounds

if (m_outlineThickness != 0)

{

const float outline = std::abs(std::ceil(m_outlineThickness));

minX -= outline;

maxX += outline;

minY -= outline;

maxY += outline;

}

// If we're using the underlined style, add the last line

if (isUnderlined && (x > 0))

{

addLine(m_vertices, x, y, m_fillColor, underlineOffset, underlineThickness);

if (m_outlineThickness != 0)

addLine(m_outlineVertices, x, y, m_outlineColor, underlineOffset, underlineThickness, m_outlineThickness);

}

// If we're using the strike through style, add the last line across all characters

if (isStrikeThrough && (x > 0))

{

addLine(m_vertices, x, y, m_fillColor, strikeThroughOffset, underlineThickness);

if (m_outlineThickness != 0)

addLine(m_outlineVertices, x, y, m_outlineColor, strikeThroughOffset, underlineThickness, m_outlineThickness);

}

// Update the bounding rectangle

m_bounds.position = Vector2f(minX, minY);

m_bounds.size = Vector2f(maxX, maxY) - Vector2f(minX, minY);