#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/controls/control-depth-index-ranges.h>
+#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/internal/text/glyph-run.h>
#include <dali-toolkit/internal/text/rendering/atlas/atlas-glyph-manager.h>
#include <dali-toolkit/internal/text/rendering/atlas/atlas-mesh-factory.h>
namespace
{
#if defined(DEBUG_ENABLED)
- Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_RENDERING");
+ Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_RENDERING");
#endif
const float ZERO( 0.0f );
struct MeshRecord
{
MeshRecord()
- : mColor( Color::BLACK ),
- mAtlasId( 0 )
+ : mAtlasId( 0u )
{
}
- Vector4 mColor;
uint32_t mAtlasId;
AtlasManager::Mesh2D mMesh;
FrameBufferImage mBuffer;
mRight( 0.0f ),
mUnderlinePosition( 0.0f ),
mUnderlineThickness( 0.0f ),
- mMeshRecordIndex( 0 )
+ mMeshRecordIndex( 0u )
{
}
mQuadVertexFormat[ "aPosition" ] = Property::VECTOR2;
mQuadVertexFormat[ "aTexCoord" ] = Property::VECTOR2;
- mQuadIndexFormat[ "indices" ] = Property::INTEGER;
+ mQuadVertexFormat[ "aColor" ] = Property::VECTOR4;
}
bool IsGlyphUnderlined( GlyphIndex index,
void AddGlyphs( Text::ViewInterface& view,
const Vector<Vector2>& positions,
const Vector<GlyphInfo>& glyphs,
+ const Vector4& defaultColor,
+ const Vector4* const colorsBuffer,
+ const ColorIndex* const colorIndicesBuffer,
int depth )
{
AtlasManager::AtlasSlot slot;
mDepth = depth;
const Vector2& actorSize( view.GetControlSize() );
- const Vector2 halfActorSize( actorSize * 0.5f );
- const Vector4& textColor( view.GetTextColor() );
+ 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 bool useDefaultColor = ( NULL == colorsBuffer );
+
// Get the underline runs.
const Length numberOfUnderlineRuns = view.GetNumberOfUnderlineRuns();
Vector<GlyphRun> underlineRuns;
thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || underlineGlyph;
// No operation for white space
- if ( glyph.width && glyph.height )
+ if( glyph.width && glyph.height )
{
// Are we still using the same fontId as previous
- if ( underlineGlyph && ( glyph.fontId != lastUnderlinedFontId ) )
+ if( underlineGlyph && ( glyph.fontId != lastUnderlinedFontId ) )
{
// We need to fetch fresh font underline metrics
FontMetrics fontMetrics;
}
// Clamp the underline position at the font descender and check for ( as EFL describes it ) a broken font
- if ( currentUnderlinePosition > descender )
+ if( currentUnderlinePosition > descender )
{
currentUnderlinePosition = descender;
}
+
if( fabsf( currentUnderlinePosition ) < Math::MACHINE_EPSILON_1000 )
{
// Move offset down by one ( EFL behavior )
lastUnderlinedFontId = glyph.fontId;
} // underline
- if ( !mGlyphManager.IsCached( glyph.fontId, glyph.index, slot ) )
+ if( !mGlyphManager.IsCached( glyph.fontId, glyph.index, slot ) )
{
// Select correct size for new atlas if needed....?
- if ( lastFontId != glyph.fontId )
+ if( lastFontId != glyph.fontId )
{
- for ( uint32_t j = 0; j < mBlockSizes.size(); ++j )
+ uint32_t index = 0u;
+ for( std::vector<MaxBlockSize>::const_iterator it = mBlockSizes.begin(),
+ endIt = mBlockSizes.end();
+ it != endIt;
+ ++it, ++index )
{
- if ( mBlockSizes[ j ].mFontId == glyph.fontId )
+ const MaxBlockSize& blockSize = *it;
+ if( blockSize.mFontId == glyph.fontId )
{
- currentBlockSize = j;
+ currentBlockSize = index;
mGlyphManager.SetNewAtlasSize( DEFAULT_ATLAS_WIDTH,
DEFAULT_ATLAS_HEIGHT,
- mBlockSizes[ j ].mNeededBlockWidth,
- mBlockSizes[ j ].mNeededBlockHeight );
+ blockSize.mNeededBlockWidth,
+ blockSize.mNeededBlockHeight );
}
}
}
// Create a new image for the glyph
- BufferImage bitmap = mFontClient.CreateBitmap( glyph.fontId, glyph.index );
- if ( bitmap )
+ PixelData bitmap = mFontClient.CreateBitmap( glyph.fontId, glyph.index );
+ if( bitmap )
{
+ MaxBlockSize& blockSize = mBlockSizes[currentBlockSize];
+
// Ensure that the next image will fit into the current block size
bool setSize = false;
- if ( bitmap.GetWidth() > mBlockSizes[ currentBlockSize ].mNeededBlockWidth )
+ if( bitmap.GetWidth() > blockSize.mNeededBlockWidth )
{
setSize = true;
- mBlockSizes[ currentBlockSize ].mNeededBlockWidth = bitmap.GetWidth();
+ blockSize.mNeededBlockWidth = bitmap.GetWidth();
}
- if ( bitmap.GetHeight() > mBlockSizes[ currentBlockSize ].mNeededBlockHeight )
+ if( bitmap.GetHeight() > blockSize.mNeededBlockHeight )
{
setSize = true;
- mBlockSizes[ currentBlockSize ].mNeededBlockHeight = bitmap.GetHeight();
+ blockSize.mNeededBlockHeight = bitmap.GetHeight();
}
- if ( setSize )
+ if( setSize )
{
mGlyphManager.SetNewAtlasSize( DEFAULT_ATLAS_WIDTH,
DEFAULT_ATLAS_HEIGHT,
- mBlockSizes[ currentBlockSize ].mNeededBlockWidth,
- mBlockSizes[ currentBlockSize ].mNeededBlockHeight );
+ blockSize.mNeededBlockWidth,
+ blockSize.mNeededBlockHeight );
}
// Locate a new slot for our glyph
}
// Move the origin (0,0) of the mesh to the center of the actor
- Vector2 position = *( positionsBuffer + i ) - halfActorSize;
+ const Vector2 position = *( positionsBuffer + i ) - halfTextSize;
// Generate mesh data for this quad, plugging in our supplied position
AtlasManager::Mesh2D newMesh;
textCacheEntry.mIndex = glyph.index;
newTextCache.PushBack( textCacheEntry );
+ AtlasManager::Vertex2D* verticesBuffer = newMesh.mVertices.Begin();
+
// Adjust the vertices if the fixed-size font should be down-scaled
if( glyph.scaleFactor > 0 )
{
- for( unsigned int i=0; i<newMesh.mVertices.Count(); ++i )
+ for( unsigned int index = 0u, size = newMesh.mVertices.Count();
+ index < size;
+ ++index )
{
- newMesh.mVertices[i].mPosition.x = position.x + ( ( newMesh.mVertices[i].mPosition.x - position.x ) * glyph.scaleFactor );
- newMesh.mVertices[i].mPosition.y = position.y + ( ( newMesh.mVertices[i].mPosition.y - position.y ) * glyph.scaleFactor );
+ AtlasManager::Vertex2D& vertex = *( verticesBuffer + index );
+
+ // Set the position of the vertex.
+ vertex.mPosition.x = position.x + ( ( vertex.mPosition.x - position.x ) * glyph.scaleFactor );
+ vertex.mPosition.y = position.y + ( ( vertex.mPosition.y - position.y ) * glyph.scaleFactor );
}
}
+ // Get the color of the character.
+ const ColorIndex colorIndex = useDefaultColor ? 0u : *( colorIndicesBuffer + i );
+ const Vector4& color = ( useDefaultColor || ( 0u == colorIndex ) ) ? defaultColor : *( colorsBuffer + colorIndex - 1u );
+
+ for( unsigned int index = 0u, size = newMesh.mVertices.Count();
+ index < size;
+ ++index )
+ {
+ AtlasManager::Vertex2D& vertex = *( verticesBuffer + index );
+
+ // Set the color of the vertex.
+ vertex.mColor = color;
+ }
+
// Find an existing mesh data object to attach to ( or create a new one, if we can't find one using the same atlas)
StitchTextMesh( meshContainer,
newMesh,
extents,
- textColor,
position.y + glyph.yBearing,
underlineGlyph,
currentUnderlinePosition,
if( thereAreUnderlinedGlyphs )
{
// Check to see if any of the text needs an underline
- GenerateUnderlines( meshContainer, extents, underlineColor, textColor );
+ GenerateUnderlines( meshContainer, extents, underlineColor );
}
// For each MeshData object, create a mesh actor and add to the renderable actor
- if ( meshContainer.size() )
+ if( !meshContainer.empty() )
{
- for ( std::vector< MeshRecord >::iterator mIt = meshContainer.begin(); mIt != meshContainer.end(); ++mIt )
+ for( std::vector< MeshRecord >::iterator it = meshContainer.begin(),
+ endIt = meshContainer.end();
+ it != endIt; ++it )
{
- Actor actor = CreateMeshActor( *mIt, actorSize );
+ MeshRecord& meshRecord = *it;
+
+ Actor actor = CreateMeshActor( meshRecord, textSize );
// Create an effect if necessary
- if ( style == STYLE_DROP_SHADOW )
+ if( style == STYLE_DROP_SHADOW )
{
+ // Change the color of the vertices.
+ for( Vector<AtlasManager::Vertex2D>::Iterator vIt = meshRecord.mMesh.mVertices.Begin(),
+ vEndIt = meshRecord.mMesh.mVertices.End();
+ vIt != vEndIt;
+ ++vIt )
+ {
+ AtlasManager::Vertex2D& vertex = *vIt;
+
+ vertex.mColor = shadowColor;
+ }
+
// Create a container actor to act as a common parent for text and shadow, to avoid color inheritence issues.
Actor containerActor = Actor::New();
containerActor.SetParentOrigin( ParentOrigin::CENTER );
containerActor.SetSize( actorSize );
- Actor shadowActor = Actor::New();
+ Actor shadowActor = CreateMeshActor( meshRecord, textSize );
#if defined(DEBUG_ENABLED)
shadowActor.SetName( "Text Shadow renderable actor" );
#endif
// Offset shadow in x and y
shadowActor.RegisterProperty("uOffset", shadowOffset );
- if ( actor.GetRendererCount() )
+ if( actor.GetRendererCount() )
{
- Dali::Renderer renderer( actor.GetRendererAt( 0 ) );
- Geometry geometry = renderer.GetGeometry();
- Material material = renderer.GetMaterial();
-
- Dali::Renderer shadowRenderer = Dali::Renderer::New( geometry, material );
- shadowRenderer.SetDepthIndex( renderer.GetDepthIndex() - 1 );
- shadowActor.AddRenderer( shadowRenderer );
- shadowActor.SetParentOrigin( ParentOrigin::CENTER );
- shadowActor.SetSize( actorSize );
- shadowActor.SetColor( shadowColor );
+ Dali::Renderer renderer( shadowActor.GetRendererAt( 0 ) );
+ int depthIndex = renderer.GetProperty<int>(Dali::Renderer::Property::DEPTH_INDEX);
+ renderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, depthIndex - 1 );
containerActor.Add( shadowActor );
containerActor.Add( actor );
+#if defined(DEBUG_ENABLED)
+ containerActor.SetName("TextContainer");
+#endif
actor = containerActor;
}
}
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%s\n", metrics.mVerboseGlyphCounts.c_str() );
- for ( uint32_t i = 0; i < metrics.mAtlasMetrics.mAtlasCount; ++i )
+ for( uint32_t i = 0; i < metrics.mAtlasMetrics.mAtlasCount; ++i )
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Atlas [%i] %sPixels: %s Size: %ix%i, BlockSize: %ix%i, BlocksUsed: %i/%i\n",
i + 1, i > 8 ? "" : " ",
void RemoveText()
{
- for ( Vector< TextCacheEntry >::Iterator oldTextIter = mTextCache.Begin(); oldTextIter != mTextCache.End(); ++oldTextIter )
+ for( Vector< TextCacheEntry >::Iterator oldTextIter = mTextCache.Begin(); oldTextIter != mTextCache.End(); ++oldTextIter )
{
mGlyphManager.AdjustReferenceCount( oldTextIter->mFontId, oldTextIter->mIndex, -1/*decrement*/ );
}
Actor CreateMeshActor( const MeshRecord& meshRecord, const Vector2& actorSize )
{
- PropertyBuffer quadVertices = PropertyBuffer::New( mQuadVertexFormat, meshRecord.mMesh.mVertices.Size() );
- PropertyBuffer quadIndices = PropertyBuffer::New( mQuadIndexFormat, meshRecord.mMesh.mIndices.Size() );
- quadVertices.SetData( const_cast< AtlasManager::Vertex2D* >( &meshRecord.mMesh.mVertices[ 0 ] ) );
- quadIndices.SetData( const_cast< unsigned int* >( &meshRecord.mMesh.mIndices[ 0 ] ) );
+ PropertyBuffer quadVertices = PropertyBuffer::New( mQuadVertexFormat );
+ quadVertices.SetData( const_cast< AtlasManager::Vertex2D* >( &meshRecord.mMesh.mVertices[ 0 ] ), meshRecord.mMesh.mVertices.Size() );
Geometry quadGeometry = Geometry::New();
quadGeometry.AddVertexBuffer( quadVertices );
- quadGeometry.SetIndexBuffer( quadIndices );
-
- Material material = mGlyphManager.GetMaterial( meshRecord.mAtlasId );
- Dali::Renderer renderer = Dali::Renderer::New( quadGeometry, material );
- renderer.SetDepthIndex( CONTENT_DEPTH_INDEX + mDepth );
+ quadGeometry.SetIndexBuffer( &meshRecord.mMesh.mIndices[0], meshRecord.mMesh.mIndices.Size() );
+
+ TextureSet textureSet( mGlyphManager.GetTextures( meshRecord.mAtlasId ) );
+ Shader shader( mGlyphManager.GetShader( meshRecord.mAtlasId ) );
+ Dali::Renderer renderer = Dali::Renderer::New( quadGeometry, shader );
+ renderer.SetTextures( textureSet );
+ renderer.SetProperty( Dali::Renderer::Property::BLEND_MODE, BlendMode::ON );
+ renderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, DepthIndex::CONTENT + mDepth );
Actor actor = Actor::New();
#if defined(DEBUG_ENABLED)
actor.SetName( "Text renderable actor" );
#endif
actor.AddRenderer( renderer );
- actor.SetParentOrigin( ParentOrigin::CENTER ); // Keep all of the origins aligned
+
+ // Keep all of the origins aligned
+ actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
+ actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
actor.SetSize( actorSize );
- actor.SetColor( meshRecord.mColor );
actor.RegisterProperty("uOffset", Vector2::ZERO );
return actor;
}
void StitchTextMesh( std::vector< MeshRecord >& meshContainer,
AtlasManager::Mesh2D& newMesh,
Vector< Extent >& extents,
- const Vector4& color,
float baseLine,
bool underlineGlyph,
float underlinePosition,
mIt != mEndIt;
++mIt, ++index )
{
- if ( slot.mAtlasId == mIt->mAtlasId && color == mIt->mColor )
+ if( slot.mAtlasId == mIt->mAtlasId )
{
// Append the mesh to the existing mesh and adjust any extents
Toolkit::Internal::AtlasMeshFactory::AppendMesh( mIt->mMesh, newMesh );
MeshRecord meshRecord;
meshRecord.mAtlasId = slot.mAtlasId;
meshRecord.mMesh = newMesh;
- meshRecord.mColor = color;
meshContainer.push_back( meshRecord );
if( underlineGlyph )
void CalculateBlocksSize( const Vector<GlyphInfo>& glyphs )
{
- MaxBlockSize maxBlockSize;
- for ( uint32_t i = 0; i < glyphs.Size(); ++i )
+ for( Vector<GlyphInfo>::ConstIterator glyphIt = glyphs.Begin(),
+ glyphEndIt = glyphs.End();
+ glyphIt != glyphEndIt;
+ ++glyphIt )
{
- FontId fontId = glyphs[ i ].fontId;
+ const FontId fontId = (*glyphIt).fontId;
bool foundFont = false;
- for ( uint32_t j = 0; j < mBlockSizes.size(); ++j )
+
+ for( std::vector< MaxBlockSize >::const_iterator blockIt = mBlockSizes.begin(),
+ blockEndIt = mBlockSizes.end();
+ blockIt != blockEndIt;
+ ++blockIt )
{
- if ( mBlockSizes[ j ].mFontId == fontId )
+ if( (*blockIt).mFontId == fontId )
{
foundFont = true;
+ break;
}
}
+
if ( !foundFont )
{
FontMetrics fontMetrics;
mFontClient.GetFontMetrics( fontId, fontMetrics );
+
+ MaxBlockSize maxBlockSize;
maxBlockSize.mNeededBlockWidth = static_cast< uint32_t >( fontMetrics.height );
- maxBlockSize.mNeededBlockHeight = static_cast< uint32_t >( fontMetrics.height );
+ maxBlockSize.mNeededBlockHeight = maxBlockSize.mNeededBlockWidth;
maxBlockSize.mFontId = fontId;
+
mBlockSizes.push_back( maxBlockSize );
}
}
void GenerateUnderlines( std::vector< MeshRecord >& meshRecords,
Vector< Extent >& extents,
- const Vector4& underlineColor,
- const Vector4& textColor )
+ const Vector4& underlineColor )
{
AtlasManager::Mesh2D newMesh;
unsigned short faceIndex = 0;
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 );
faceIndex += 4;
- if ( underlineColor == textColor )
- {
- Toolkit::Internal::AtlasMeshFactory::AppendMesh( meshRecords[ index ].mMesh, newMesh );
- }
- else
- {
- MeshRecord record;
- record.mMesh = newMesh;
- record.mAtlasId = meshRecords[ index ].mAtlasId;
- record.mColor = underlineColor;
- meshRecords.push_back( record );
- }
+ Toolkit::Internal::AtlasMeshFactory::AppendMesh( meshRecords[ index ].mMesh, newMesh );
}
}
std::vector< MaxBlockSize > mBlockSizes; ///> Maximum size needed to contain a glyph in a block within a new atlas
Vector< TextCacheEntry > mTextCache; ///> Caches data from previous render
Property::Map mQuadVertexFormat; ///> Describes the vertex format for text
- Property::Map mQuadIndexFormat; ///> Describes the index format for text
int mDepth; ///> DepthIndex passed by control when connect to stage
};
Actor AtlasRenderer::Render( Text::ViewInterface& view, int depth )
{
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Text::AtlasRenderer::Render()\n" );
+
UnparentAndReset( mImpl->mActor );
Length numberOfGlyphs = view.GetNumberOfGlyphs();
positions.Begin(),
0u,
numberOfGlyphs );
+
glyphs.Resize( numberOfGlyphs );
positions.Resize( numberOfGlyphs );
+ const Vector4* const colorsBuffer = view.GetColors();
+ const ColorIndex* const colorIndicesBuffer = view.GetColorIndices();
+ const Vector4& defaultColor = view.GetTextColor();
+
mImpl->AddGlyphs( view,
positions,
glyphs,
+ defaultColor,
+ colorsBuffer,
+ colorIndicesBuffer,
depth );
- /* In the case where AddGlyphs does not create a renderable Actor for example when glyphs are all whitespace create a new Actor. */
- /* This renderable actor is used to position the text, other "decorations" can rely on there always being an Actor regardless of it is whitespace or regular text*/
+ /* In the case where AddGlyphs does not create a renderable Actor for example when glyphs are all whitespace create a new Actor. */
+ /* This renderable actor is used to position the text, other "decorations" can rely on there always being an Actor regardless of it is whitespace or regular text. */
if ( !mImpl->mActor )
{
mImpl->mActor = Actor::New();