X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Frendering%2Fatlas%2Ftext-atlas-renderer.cpp;h=206d7f659d90e25ce672a61b6e92b7fc77f93696;hp=1023dc46d1c5c42fb8db125b31f7d86bc3946ed0;hb=04194fd795542d80b5cf7c1b954ca14593e536d4;hpb=3907251e7ae113572a758325504a1211dbcb4038 diff --git a/dali-toolkit/internal/text/rendering/atlas/text-atlas-renderer.cpp b/dali-toolkit/internal/text/rendering/atlas/text-atlas-renderer.cpp index 1023dc4..206d7f6 100644 --- a/dali-toolkit/internal/text/rendering/atlas/text-atlas-renderer.cpp +++ b/dali-toolkit/internal/text/rendering/atlas/text-atlas-renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -46,7 +46,8 @@ Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT const float ZERO(0.0f); const float HALF(0.5f); const float ONE(1.0f); -const uint32_t DOUBLE_PIXEL_PADDING = 4u;//Padding will be added twice to Atlas +const float ONE_AND_A_HALF(1.5f); +const uint32_t DOUBLE_PIXEL_PADDING = 4u; //Padding will be added twice to Atlas const uint16_t NO_OUTLINE = 0u; } // namespace @@ -70,7 +71,7 @@ struct AtlasRenderer::Impl }; /** - * brief Struct used to generate the underline mesh. + * brief Struct used to generate the underline/striketthrough mesh. * There is one Extent per line of text. */ struct Extent @@ -80,9 +81,11 @@ struct AtlasRenderer::Impl mLeft(0.0f), mRight(0.0f), mUnderlinePosition(0.0f), - mUnderlineThickness(0.0f), + mLineThickness(0.0f), mMeshRecordIndex(0u), - mUnderlineChunkId(0u) + mUnderlineChunkId(0u), + mStrikethroughPosition(0.0f), + mStrikethroughChunkId(0u) { } @@ -90,9 +93,11 @@ struct AtlasRenderer::Impl float mLeft; float mRight; float mUnderlinePosition; - float mUnderlineThickness; + float mLineThickness; uint32_t mMeshRecordIndex; uint32_t mUnderlineChunkId; + float mStrikethroughPosition; + uint32_t mStrikethroughChunkId; }; struct MaxBlockSize @@ -171,6 +176,30 @@ struct AtlasRenderer::Impl return false; } + bool doGlyphHaveStrikethrough(GlyphIndex index, + const Vector& strikethroughRuns, + Vector4& strikethroughColor) + { + for(Vector::ConstIterator it = strikethroughRuns.Begin(), + endIt = strikethroughRuns.End(); + it != endIt; + ++it) + { + const StrikethroughGlyphRun& run = *it; + + if((run.glyphRun.glyphIndex <= index) && (index < run.glyphRun.glyphIndex + run.glyphRun.numberOfGlyphs)) + { + if(run.isColorSet) + { + strikethroughColor = run.color; + } + + return true; + } + } + + return false; + } void CacheGlyph(const GlyphInfo& glyph, FontId lastFontId, const AtlasGlyphManager::GlyphStyle& style, AtlasManager::AtlasSlot& slot) { const Size& defaultTextAtlasSize = mFontClient.GetDefaultTextAtlasSize(); //Retrieve default size of text-atlas-block from font-client. @@ -249,13 +278,12 @@ struct AtlasRenderer::Impl // If CheckAtlas in AtlasManager::Add can't fit the bitmap in the current atlas it will create a new atlas // Setting the block size and size of new atlas does not mean a new one will be created. An existing atlas may still surffice. - uint32_t default_width = defaultTextAtlasSize.width; + uint32_t default_width = defaultTextAtlasSize.width; uint32_t default_height = defaultTextAtlasSize.height; - while ( + while( (blockSize.mNeededBlockWidth >= (default_width - (DOUBLE_PIXEL_PADDING + 1u)) || - blockSize.mNeededBlockHeight >= (default_height - (DOUBLE_PIXEL_PADDING + 1u))) - && + blockSize.mNeededBlockHeight >= (default_height - (DOUBLE_PIXEL_PADDING + 1u))) && (default_width < maximumTextAtlasSize.width && default_height < maximumTextAtlasSize.height)) { @@ -284,27 +312,32 @@ struct AtlasRenderer::Impl const Vector4& color, uint16_t outline, AtlasManager::AtlasSlot& slot, - bool underlineGlyph, + bool decorationlineGlyph, float currentUnderlinePosition, - float currentUnderlineThickness, + float currentlineThickness, std::vector& meshContainer, Vector& newTextCache, Vector& extents, - uint32_t underlineChunkId) + uint32_t underlineChunkId, + bool isGlyphCached, + uint32_t strikethroughChunkId) { // Generate mesh data for this quad, plugging in our supplied position AtlasManager::Mesh2D newMesh; mGlyphManager.GenerateMeshData(slot.mImageId, position, newMesh); - TextCacheEntry textCacheEntry; - textCacheEntry.mFontId = glyph.fontId; - textCacheEntry.mImageId = slot.mImageId; - textCacheEntry.mIndex = glyph.index; - textCacheEntry.mOutlineWidth = outline; - textCacheEntry.isItalic = glyph.isItalicRequired; - textCacheEntry.isBold = glyph.isBoldRequired; - - newTextCache.PushBack(textCacheEntry); + if(!isGlyphCached) + { + TextCacheEntry textCacheEntry; + textCacheEntry.mFontId = glyph.fontId; + textCacheEntry.mImageId = slot.mImageId; + textCacheEntry.mIndex = glyph.index; + textCacheEntry.mOutlineWidth = outline; + textCacheEntry.isItalic = glyph.isItalicRequired; + textCacheEntry.isBold = glyph.isBoldRequired; + + newTextCache.PushBack(textCacheEntry); + } AtlasManager::Vertex2D* verticesBuffer = newMesh.mVertices.Begin(); @@ -323,11 +356,13 @@ struct AtlasRenderer::Impl newMesh, extents, position.y + glyph.yBearing, - underlineGlyph, + decorationlineGlyph, currentUnderlinePosition, - currentUnderlineThickness, + currentlineThickness, slot, - underlineChunkId); + underlineChunkId, + position.y + (glyph.height * HALF), + strikethroughChunkId); } void CreateActors(const std::vector& meshContainer, @@ -417,21 +452,34 @@ struct AtlasRenderer::Impl std::vector meshContainer; std::vector meshContainerOutline; Vector extents; + Vector strikethroughExtents; mDepth = depth; - const Vector2& textSize(view.GetLayoutSize()); - const Vector2 halfTextSize(textSize * 0.5f); - const Vector2& shadowOffset(view.GetShadowOffset()); - const Vector4& shadowColor(view.GetShadowColor()); - const bool underlineEnabled = view.IsUnderlineEnabled(); - const Vector4& underlineColor(view.GetUnderlineColor()); - const float underlineHeight = view.GetUnderlineHeight(); - const uint16_t outlineWidth = view.GetOutlineWidth(); - const Vector4& outlineColor(view.GetOutlineColor()); - const bool isOutline = 0u != outlineWidth; - const GlyphInfo* hyphens = view.GetHyphens(); - const Length* hyphenIndices = view.GetHyphenIndices(); - const Length hyphensCount = view.GetHyphensCount(); + const Vector2& textSize(view.GetLayoutSize()); + const Vector2 halfTextSize(textSize * 0.5f); + const Vector2& shadowOffset(view.GetShadowOffset()); + const Vector4& shadowColor(view.GetShadowColor()); + const bool underlineEnabled = view.IsUnderlineEnabled(); + const Vector4& underlineColor(view.GetUnderlineColor()); + const float underlineHeight = view.GetUnderlineHeight(); + const Text::Underline::Type underlineType = view.GetUnderlineType(); + const float dashedUnderlineWidth = view.GetDashedUnderlineWidth(); + const float dashedUnderlineGap = view.GetDashedUnderlineGap(); + const uint16_t outlineWidth = view.GetOutlineWidth(); + const Vector4& outlineColor(view.GetOutlineColor()); + const bool isOutline = 0u != outlineWidth; + const GlyphInfo* hyphens = view.GetHyphens(); + const Length* hyphenIndices = view.GetHyphenIndices(); + const Length hyphensCount = view.GetHyphensCount(); + const bool strikethroughEnabled = view.IsStrikethroughEnabled(); + const Vector4& strikethroughColor(view.GetStrikethroughColor()); + const float strikethroughHeight = view.GetStrikethroughHeight(); + Vector4 currentStrikethroughColor; + + // Elided text info. Indices according to elided text. + const auto startIndexOfGlyphs = view.GetStartIndexOfElidedGlyphs(); + const auto firstMiddleIndexOfElidedGlyphs = view.GetFirstMiddleIndexOfElidedGlyphs(); + const auto secondMiddleIndexOfElidedGlyphs = view.GetSecondMiddleIndexOfElidedGlyphs(); const bool useDefaultColor = (NULL == colorsBuffer); @@ -443,13 +491,21 @@ struct AtlasRenderer::Impl 0u, numberOfUnderlineRuns); + // Get the strikethrough runs. + const Length numberOfStrikethroughRuns = view.GetNumberOfStrikethroughRuns(); + Vector strikethroughRuns; + strikethroughRuns.Resize(numberOfStrikethroughRuns); + view.GetStrikethroughRuns(strikethroughRuns.Begin(), 0u, numberOfStrikethroughRuns); + bool thereAreUnderlinedGlyphs = false; + bool strikethroughGlyphsExist = false; - float currentUnderlinePosition = ZERO; - float currentUnderlineThickness = underlineHeight; - FontId lastFontId = 0; - FontId lastUnderlinedFontId = 0; - Style style = STYLE_NORMAL; + float currentUnderlinePosition = ZERO; + float currentUnderlineThickness = underlineHeight; + float currentStrikethroughThickness = strikethroughHeight; + FontId lastFontId = 0; + FontId lastUnderlinedFontId = 0; + Style style = STYLE_NORMAL; if(fabsf(shadowOffset.x) > Math::MACHINE_EPSILON_1 || fabsf(shadowOffset.y) > Math::MACHINE_EPSILON_1) { @@ -466,13 +522,26 @@ struct AtlasRenderer::Impl uint32_t hyphenIndex = 0; //For septated underlined chunks. (this is for Markup case) - uint32_t underlineChunkId = 0u; // give id for each chunk. - bool isPreUnderlined = false; // status of underlined for previous glyph. + uint32_t underlineChunkId = 0u; // give id for each chunk. + bool isPreUnderlined = false; // status of underlined for previous glyph. + + uint32_t strikethroughChunkId = 0u; // give id for each chunk. + bool isPrevGlyphStrikethrough = false; // status of strikethrough for previous glyph. + + //Skip hyphenIndices less than startIndexOfGlyphs or between two middle of elided text + if(hyphenIndices) + { + while((hyphenIndex < hyphensCount) && (hyphenIndices[hyphenIndex] < startIndexOfGlyphs || + (hyphenIndices[hyphenIndex] > firstMiddleIndexOfElidedGlyphs && hyphenIndices[hyphenIndex] < secondMiddleIndexOfElidedGlyphs))) + { + ++hyphenIndex; + } + } for(uint32_t i = 0, glyphSize = glyphs.Size(); i < glyphSize; ++i) { GlyphInfo glyph; - bool addHyphen = ((hyphenIndex < hyphensCount) && hyphenIndices && (i == hyphenIndices[hyphenIndex])); + bool addHyphen = ((hyphenIndex < hyphensCount) && hyphenIndices && ((i + startIndexOfGlyphs) == hyphenIndices[hyphenIndex])); if(addHyphen && hyphens) { glyph = hyphens[hyphenIndex]; @@ -486,11 +555,15 @@ struct AtlasRenderer::Impl const bool isGlyphUnderlined = underlineEnabled || IsGlyphUnderlined(i, underlineRuns); thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || isGlyphUnderlined; + currentStrikethroughColor = strikethroughColor; + const bool isStrikethroughGlyph = strikethroughEnabled || doGlyphHaveStrikethrough(i, strikethroughRuns, currentStrikethroughColor); + strikethroughGlyphsExist = strikethroughGlyphsExist || isStrikethroughGlyph; + // No operation for white space if(glyph.width && glyph.height) { // Are we still using the same fontId as previous - if(isGlyphUnderlined && (glyph.fontId != lastUnderlinedFontId)) + if((isGlyphUnderlined || isStrikethroughGlyph) && (glyph.fontId != lastUnderlinedFontId)) { // We need to fetch fresh font underline metrics FontMetrics fontMetrics; @@ -513,6 +586,19 @@ struct AtlasRenderer::Impl } } + if(fabsf(strikethroughHeight) < Math::MACHINE_EPSILON_1000) + { + // Ensure strikethrough will be at least a pixel high + if(currentStrikethroughThickness < ONE) + { + currentStrikethroughThickness = ONE; + } + else + { + currentStrikethroughThickness = ceil(currentStrikethroughThickness); + } + } + // Clamp the underline position at the font descender and check for ( as EFL describes it ) a broken font if(currentUnderlinePosition > descender) { @@ -580,7 +666,27 @@ struct AtlasRenderer::Impl meshContainer, newTextCache, extents, - underlineChunkId); + underlineChunkId, + false, + 0u); + + if(isStrikethroughGlyph) + { + GenerateMesh(glyph, + positionPlusOutlineOffset, + color, + NO_OUTLINE, + slot, + strikethroughGlyphsExist, + 0.0f, + currentStrikethroughThickness, + meshContainer, + newTextCache, + strikethroughExtents, + 0u, + true, + strikethroughChunkId); + } lastFontId = glyph.fontId; // Prevents searching for existing blocksizes when string of the same fontId. } @@ -598,18 +704,26 @@ struct AtlasRenderer::Impl meshContainerOutline, newTextCache, extents, + 0u, + false, 0u); } - //The new underlined chunk. Add new id if they are not consecutive indices (this is for Markup case) // Examples: "Hello World Hello World", "World Hello World", " World Hello World" - if( isPreUnderlined && (isPreUnderlined != isGlyphUnderlined)) + if(isPreUnderlined && (isPreUnderlined != isGlyphUnderlined)) { underlineChunkId++; } //Keep status of underlined for previous glyph to check consecutive indices isPreUnderlined = isGlyphUnderlined; + + if(isPrevGlyphStrikethrough && !isStrikethroughGlyph) + { + strikethroughChunkId++; + } + + isPrevGlyphStrikethrough = isStrikethroughGlyph; } if(addHyphen) @@ -625,7 +739,13 @@ struct AtlasRenderer::Impl if(thereAreUnderlinedGlyphs) { // Check to see if any of the text needs an underline - GenerateUnderlines(meshContainer, extents, underlineColor); + GenerateUnderlines(meshContainer, extents, underlineColor, underlineType, dashedUnderlineWidth, dashedUnderlineGap); + } + + if(strikethroughGlyphsExist) + { + // Check to see if any of the text needs a strikethrough + GenerateStrikethrough(meshContainer, strikethroughExtents, currentStrikethroughColor); } // For each MeshData object, create a mesh actor and add to the renderable actor @@ -762,11 +882,13 @@ struct AtlasRenderer::Impl AtlasManager::Mesh2D& newMesh, Vector& extents, float baseLine, - bool underlineGlyph, + bool decorationlineGlyph, float underlinePosition, - float underlineThickness, + float lineThickness, AtlasManager::AtlasSlot& slot, - uint32_t underlineChunkId) + uint32_t underlineChunkId, + float strikethroughPosition, + uint32_t strikethroughChunkId) { if(slot.mImageId) { @@ -785,7 +907,7 @@ struct AtlasRenderer::Impl // Append the mesh to the existing mesh and adjust any extents Toolkit::Internal::AtlasMeshFactory::AppendMesh(mIt->mMesh, newMesh); - if(underlineGlyph) + if(decorationlineGlyph) { AdjustExtents(extents, meshContainer, @@ -794,8 +916,10 @@ struct AtlasRenderer::Impl right, baseLine, underlinePosition, - underlineThickness, - underlineChunkId); + lineThickness, + underlineChunkId, + strikethroughPosition, + strikethroughChunkId); } return; @@ -808,7 +932,7 @@ struct AtlasRenderer::Impl meshRecord.mMesh = newMesh; meshContainer.push_back(meshRecord); - if(underlineGlyph) + if(decorationlineGlyph) { // Adjust extents for this new meshrecord AdjustExtents(extents, @@ -818,8 +942,10 @@ struct AtlasRenderer::Impl right, baseLine, underlinePosition, - underlineThickness, - underlineChunkId); + lineThickness, + underlineChunkId, + strikethroughPosition, + strikethroughChunkId); } } } @@ -831,8 +957,10 @@ struct AtlasRenderer::Impl float right, float baseLine, float underlinePosition, - float underlineThickness, - uint32_t underlineChunkId) + float lineThickness, + uint32_t underlineChunkId, + float strikethroughPosition, + uint32_t strikethroughChunkId) { bool foundExtent = false; for(Vector::Iterator eIt = extents.Begin(), @@ -840,7 +968,7 @@ struct AtlasRenderer::Impl eIt != eEndIt; ++eIt) { - if(Equals(baseLine, eIt->mBaseLine) && underlineChunkId == eIt->mUnderlineChunkId) + if(Equals(baseLine, eIt->mBaseLine) && underlineChunkId == eIt->mUnderlineChunkId && strikethroughChunkId == eIt->mStrikethroughChunkId) { foundExtent = true; if(left < eIt->mLeft) @@ -856,22 +984,24 @@ struct AtlasRenderer::Impl { eIt->mUnderlinePosition = underlinePosition; } - if(underlineThickness > eIt->mUnderlineThickness) + if(lineThickness > eIt->mLineThickness) { - eIt->mUnderlineThickness = underlineThickness; + eIt->mLineThickness = lineThickness; } } } if(!foundExtent) { Extent extent; - extent.mLeft = left; - extent.mRight = right; - extent.mBaseLine = baseLine; - extent.mUnderlinePosition = underlinePosition; - extent.mUnderlineThickness = underlineThickness; - extent.mMeshRecordIndex = index; - extent.mUnderlineChunkId = underlineChunkId; + extent.mLeft = left; + extent.mRight = right; + extent.mBaseLine = baseLine; + extent.mUnderlinePosition = underlinePosition; + extent.mMeshRecordIndex = index; + extent.mUnderlineChunkId = underlineChunkId; + extent.mLineThickness = lineThickness; + extent.mStrikethroughPosition = strikethroughPosition; + extent.mStrikethroughChunkId = strikethroughChunkId; extents.PushBack(extent); } } @@ -914,9 +1044,182 @@ struct AtlasRenderer::Impl } } - void GenerateUnderlines(std::vector& meshRecords, - Vector& extents, - const Vector4& underlineColor) + void GenerateUnderlines(std::vector& meshRecords, + Vector& extents, + const Vector4& underlineColor, + const Text::Underline::Type& underlineType, + const float& dashedUnderlineWidth, + const float& dashedUnderlineGap) + { + AtlasManager::Mesh2D newMesh; + unsigned short faceIndex = 0; + for(Vector::ConstIterator eIt = extents.Begin(), + eEndIt = extents.End(); + eIt != eEndIt; + ++eIt) + { + AtlasManager::Vertex2D vert; + uint32_t index = eIt->mMeshRecordIndex; + Vector2 uv = mGlyphManager.GetAtlasSize(meshRecords[index].mAtlasId); + + // Make sure we don't hit texture edge for single pixel texture ( filled pixel is in top left of every atlas ) + float u = HALF / uv.x; + float v = HALF / uv.y; + float thickness = eIt->mLineThickness; + float ShiftLineBy = (underlineType == Text::Underline::Type::DOUBLE) ? (thickness * ONE_AND_A_HALF) : (thickness * HALF); + float baseLine = eIt->mBaseLine + eIt->mUnderlinePosition - ShiftLineBy; + float tlx = eIt->mLeft; + float brx = eIt->mRight; + + if(underlineType == Text::Underline::Type::DASHED) + { + float dashTlx = tlx; + float dashBrx = tlx; + faceIndex = 0; + + AtlasManager::Mesh2D newMesh; + while((dashTlx >= tlx) && (dashTlx < brx) && ((dashTlx + dashedUnderlineWidth) <= brx)) + { + dashBrx = dashTlx + dashedUnderlineWidth; + + //The top left edge of the underline + vert.mPosition.x = dashTlx; + vert.mPosition.y = baseLine; + vert.mTexCoords.x = ZERO; + vert.mTexCoords.y = ZERO; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + //The top right edge of the underline + vert.mPosition.x = dashBrx; + vert.mPosition.y = baseLine; + vert.mTexCoords.x = u; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + //The bottom left edge of the underline + vert.mPosition.x = dashTlx; + vert.mPosition.y = baseLine + thickness; + vert.mTexCoords.x = ZERO; + vert.mTexCoords.y = v; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + //The bottom right edge of the underline + vert.mPosition.x = dashBrx; + vert.mPosition.y = baseLine + thickness; + vert.mTexCoords.x = u; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + dashTlx = dashBrx + dashedUnderlineGap; // The next dash will start at the right of the current dash plus the gap + + // Six indices in counter clockwise winding + newMesh.mIndices.PushBack(faceIndex + 1u); + newMesh.mIndices.PushBack(faceIndex); + newMesh.mIndices.PushBack(faceIndex + 2u); + newMesh.mIndices.PushBack(faceIndex + 2u); + newMesh.mIndices.PushBack(faceIndex + 3u); + newMesh.mIndices.PushBack(faceIndex + 1u); + + faceIndex += 4; + + Toolkit::Internal::AtlasMeshFactory::AppendMesh(meshRecords[index].mMesh, newMesh); + } + } + else + { + // It's either SOLID or DOUBLE so we need to generate the first solid underline anyway. + vert.mPosition.x = tlx; + vert.mPosition.y = baseLine; + vert.mTexCoords.x = ZERO; + vert.mTexCoords.y = ZERO; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + vert.mPosition.x = brx; + vert.mPosition.y = baseLine; + vert.mTexCoords.x = u; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + vert.mPosition.x = tlx; + vert.mPosition.y = baseLine + thickness; + vert.mTexCoords.x = ZERO; + vert.mTexCoords.y = v; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + vert.mPosition.x = brx; + vert.mPosition.y = baseLine + thickness; + vert.mTexCoords.x = u; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + // Six indices in counter clockwise winding + newMesh.mIndices.PushBack(faceIndex + 1u); + newMesh.mIndices.PushBack(faceIndex); + newMesh.mIndices.PushBack(faceIndex + 2u); + newMesh.mIndices.PushBack(faceIndex + 2u); + newMesh.mIndices.PushBack(faceIndex + 3u); + newMesh.mIndices.PushBack(faceIndex + 1u); + faceIndex += 4; + + Toolkit::Internal::AtlasMeshFactory::AppendMesh(meshRecords[index].mMesh, newMesh); + + if(underlineType == Text::Underline::Type::DOUBLE) + { + baseLine += 2 * thickness; + + //The top left edge of the underline + vert.mPosition.x = tlx; + vert.mPosition.y = baseLine; // Vertical start of the second underline + vert.mTexCoords.x = ZERO; + vert.mTexCoords.y = ZERO; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + //The top right edge of the underline + vert.mPosition.x = brx; + vert.mPosition.y = baseLine; + vert.mTexCoords.x = u; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + //The bottom left edge of the underline + vert.mPosition.x = tlx; + vert.mPosition.y = baseLine + thickness; // Vertical End of the second underline + vert.mTexCoords.x = ZERO; + vert.mTexCoords.y = v; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + //The bottom right edge of the underline + vert.mPosition.x = brx; + vert.mPosition.y = baseLine + thickness; + vert.mTexCoords.x = u; + vert.mColor = underlineColor; + newMesh.mVertices.PushBack(vert); + + // Six indices in counter clockwise winding + newMesh.mIndices.PushBack(faceIndex + 1u); + newMesh.mIndices.PushBack(faceIndex); + newMesh.mIndices.PushBack(faceIndex + 2u); + newMesh.mIndices.PushBack(faceIndex + 2u); + newMesh.mIndices.PushBack(faceIndex + 3u); + newMesh.mIndices.PushBack(faceIndex + 1u); + + faceIndex += 4; + + Toolkit::Internal::AtlasMeshFactory::AppendMesh(meshRecords[index].mMesh, newMesh); + } + } + } + } + + void GenerateStrikethrough(std::vector& meshRecords, + Vector& extents, + const Vector4& strikethroughColor) { AtlasManager::Mesh2D newMesh; unsigned short faceIndex = 0; @@ -930,37 +1233,37 @@ struct AtlasRenderer::Impl Vector2 uv = mGlyphManager.GetAtlasSize(meshRecords[index].mAtlasId); // Make sure we don't hit texture edge for single pixel texture ( filled pixel is in top left of every atlas ) - float u = HALF / uv.x; - float v = HALF / uv.y; - float thickness = eIt->mUnderlineThickness; - float baseLine = eIt->mBaseLine + eIt->mUnderlinePosition - (thickness * HALF); - float tlx = eIt->mLeft; - float brx = eIt->mRight; + float u = HALF / uv.x; + float v = HALF / uv.y; + float thickness = eIt->mLineThickness; + float tlx = eIt->mLeft; + float brx = eIt->mRight; + float strikethroughPosition = eIt->mStrikethroughPosition; vert.mPosition.x = tlx; - vert.mPosition.y = baseLine; + vert.mPosition.y = strikethroughPosition; vert.mTexCoords.x = ZERO; vert.mTexCoords.y = ZERO; - vert.mColor = underlineColor; + vert.mColor = strikethroughColor; newMesh.mVertices.PushBack(vert); vert.mPosition.x = brx; - vert.mPosition.y = baseLine; + vert.mPosition.y = strikethroughPosition; vert.mTexCoords.x = u; - vert.mColor = underlineColor; + vert.mColor = strikethroughColor; newMesh.mVertices.PushBack(vert); vert.mPosition.x = tlx; - vert.mPosition.y = baseLine + thickness; + vert.mPosition.y = strikethroughPosition + thickness; vert.mTexCoords.x = ZERO; vert.mTexCoords.y = v; - vert.mColor = underlineColor; + vert.mColor = strikethroughColor; newMesh.mVertices.PushBack(vert); vert.mPosition.x = brx; - vert.mPosition.y = baseLine + thickness; + vert.mPosition.y = strikethroughPosition + thickness; vert.mTexCoords.x = u; - vert.mColor = underlineColor; + vert.mColor = strikethroughColor; newMesh.mVertices.PushBack(vert); // Six indices in counter clockwise winding