X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Ftext%2Ftext-visual.cpp;h=b8edc7a42441aa30efdf6d6d4f57a2c0cd14b961;hp=2b40d32464149654a3148341b87f168ac16e18cd;hb=cdac11c27bab99068abd2ecabb1c54645b2f90a9;hpb=82ae5bfae69e5db5845c495270c62b35bf6c3213 diff --git a/dali-toolkit/internal/visuals/text/text-visual.cpp b/dali-toolkit/internal/visuals/text/text-visual.cpp old mode 100644 new mode 100755 index 2b40d32..b8edc7a --- a/dali-toolkit/internal/visuals/text/text-visual.cpp +++ b/dali-toolkit/internal/visuals/text/text-visual.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 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. @@ -18,15 +18,25 @@ // CLASS HEADER #include +// EXTERNAL INCLUDES +#include +#include +#include + // INTERNAL HEADER -#include -#include +#include +#include +#include #include #include #include #include #include #include +#include +#include +#include +#include namespace Dali { @@ -49,57 +59,25 @@ const char * const HORIZONTAL_ALIGNMENT_PROPERTY( "horizontalAlignment" ); const char * const VERTICAL_ALIGNMENT_PROPERTY( "verticalAlignment" ); const char * const TEXT_COLOR_PROPERTY( "textColor" ); const char * const ENABLE_MARKUP_PROPERTY( "enableMarkup" ); - -const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea"; - -const Scripting::StringEnum HORIZONTAL_ALIGNMENT_STRING_TABLE[] = -{ - { "BEGIN", Toolkit::Text::Layout::HORIZONTAL_ALIGN_BEGIN }, - { "CENTER", Toolkit::Text::Layout::HORIZONTAL_ALIGN_CENTER }, - { "END", Toolkit::Text::Layout::HORIZONTAL_ALIGN_END }, -}; -const unsigned int HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof( HORIZONTAL_ALIGNMENT_STRING_TABLE ) / sizeof( HORIZONTAL_ALIGNMENT_STRING_TABLE[0] ); - -const Scripting::StringEnum VERTICAL_ALIGNMENT_STRING_TABLE[] = -{ - { "TOP", Toolkit::Text::Layout::VERTICAL_ALIGN_TOP }, - { "CENTER", Toolkit::Text::Layout::VERTICAL_ALIGN_CENTER }, - { "BOTTOM", Toolkit::Text::Layout::VERTICAL_ALIGN_BOTTOM }, -}; -const unsigned int VERTICAL_ALIGNMENT_STRING_TABLE_COUNT = sizeof( VERTICAL_ALIGNMENT_STRING_TABLE ) / sizeof( VERTICAL_ALIGNMENT_STRING_TABLE[0] ); +const char * const SHADOW_PROPERTY( "shadow" ); +const char * const UNDERLINE_PROPERTY( "underline" ); +const char * const OUTLINE_PROPERTY( "outline" ); +const char * const BACKGROUND_PROPERTY( "textBackground" ); const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f ); -std::string GetHorizontalAlignment( Toolkit::Text::Layout::HorizontalAlignment alignment ) -{ - const char* name = Scripting::GetEnumerationName( alignment, - HORIZONTAL_ALIGNMENT_STRING_TABLE, - HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT ); - - return std::string( name ); -} - -std::string GetVerticalAlignment( Toolkit::Text::Layout::VerticalAlignment alignment ) -{ - const char* name = Scripting::GetEnumerationName< Toolkit::Text::Layout::VerticalAlignment >( alignment, - VERTICAL_ALIGNMENT_STRING_TABLE, - VERTICAL_ALIGNMENT_STRING_TABLE_COUNT ); - - return std::string( name ); -} - const char* VERTEX_SHADER = DALI_COMPOSE_SHADER( attribute mediump vec2 aPosition;\n uniform mediump mat4 uMvpMatrix;\n uniform mediump vec3 uSize;\n - uniform mediump vec4 pixelArea; + uniform mediump vec4 pixelArea;\n uniform mediump mat4 uModelMatrix;\n uniform mediump mat4 uViewMatrix;\n uniform mediump mat4 uProjection;\n varying mediump vec2 vTexCoord;\n - \n + //Visual size and offset uniform mediump vec2 offset;\n uniform mediump vec2 size;\n @@ -125,19 +103,214 @@ const char* VERTEX_SHADER = DALI_COMPOSE_SHADER( }\n ); -const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER( - varying mediump vec2 vTexCoord;\n - uniform sampler2D sTexture;\n - uniform mediump vec4 uAtlasRect;\n - uniform lowp vec4 uColor;\n - \n - void main()\n - {\n - mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n - gl_FragColor = texture2D( sTexture, texCoord ) * uColor;\n - }\n +const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT = DALI_COMPOSE_SHADER( + varying mediump vec2 vTexCoord;\n + uniform sampler2D sTexture;\n + uniform lowp vec4 uTextColorAnimatable;\n + uniform lowp vec4 uColor;\n + uniform lowp vec3 mixColor;\n + \n + void main()\n + {\n + mediump float textTexture = texture2D( sTexture, vTexCoord ).r;\n + + // Set the color of the text to what it is animated to. + gl_FragColor = uTextColorAnimatable * textTexture * uColor * vec4( mixColor, 1.0 ); + }\n +); + +const char* FRAGMENT_SHADER_MULTI_COLOR_TEXT = DALI_COMPOSE_SHADER( + varying mediump vec2 vTexCoord;\n + uniform sampler2D sTexture;\n + uniform lowp vec4 uColor;\n + uniform lowp vec3 mixColor;\n + \n + void main()\n + {\n + mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n + + gl_FragColor = textTexture * uColor * vec4( mixColor, 1.0 ); + }\n ); +const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE = DALI_COMPOSE_SHADER( + varying mediump vec2 vTexCoord;\n + uniform sampler2D sTexture;\n + uniform sampler2D sStyle;\n + uniform lowp vec4 uTextColorAnimatable;\n + uniform lowp vec4 uColor;\n + uniform lowp vec3 mixColor;\n + \n + void main()\n + {\n + mediump float textTexture = texture2D( sTexture, vTexCoord ).r;\n + mediump vec4 styleTexture = texture2D( sStyle, vTexCoord );\n + + // Draw the text as overlay above the style + gl_FragColor = ( uTextColorAnimatable * textTexture + styleTexture * ( 1.0 - uTextColorAnimatable.a * textTexture ) ) * uColor * vec4( mixColor, 1.0 );\n + }\n +); + +const char* FRAGMENT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE = DALI_COMPOSE_SHADER( + varying mediump vec2 vTexCoord;\n + uniform sampler2D sTexture;\n + uniform sampler2D sStyle;\n + uniform lowp vec4 uColor;\n + uniform lowp vec3 mixColor;\n + \n + void main()\n + {\n + mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n + mediump vec4 styleTexture = texture2D( sStyle, vTexCoord );\n + + // Draw the text as overlay above the style + gl_FragColor = ( textTexture + styleTexture * ( 1.0 - textTexture.a ) ) * uColor * vec4( mixColor, 1.0 );\n + }\n +); + +const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI = DALI_COMPOSE_SHADER( + varying mediump vec2 vTexCoord;\n + uniform sampler2D sTexture;\n + uniform sampler2D sMask;\n + uniform lowp vec4 uTextColorAnimatable;\n + uniform lowp vec4 uColor;\n + uniform lowp vec3 mixColor;\n + \n + void main()\n + {\n + mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n + mediump float maskTexture = texture2D( sMask, vTexCoord ).r;\n + + // Set the color of non-transparent pixel in text to what it is animated to. + // Markup text with multiple text colors are not animated (but can be supported later on if required). + // Emoji color are not animated. + mediump float vstep = step( 0.0001, textTexture.a );\n + textTexture.rgb = mix( textTexture.rgb, uTextColorAnimatable.rgb, vstep * maskTexture );\n + + // Draw the text as overlay above the style + gl_FragColor = textTexture * uColor * vec4( mixColor, 1.0 );\n + }\n +); + +const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI = DALI_COMPOSE_SHADER( + varying mediump vec2 vTexCoord;\n + uniform sampler2D sTexture;\n + uniform sampler2D sStyle;\n + uniform sampler2D sMask;\n + uniform lowp float uHasMultipleTextColors;\n + uniform lowp vec4 uTextColorAnimatable;\n + uniform lowp vec4 uColor;\n + uniform lowp vec3 mixColor;\n + \n + void main()\n + {\n + mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n + mediump vec4 styleTexture = texture2D( sStyle, vTexCoord );\n + mediump float maskTexture = texture2D( sMask, vTexCoord ).r;\n + + // Set the color of non-transparent pixel in text to what it is animated to. + // Markup text with multiple text colors are not animated (but can be supported later on if required). + // Emoji color are not animated. + mediump float vstep = step( 0.0001, textTexture.a );\n + textTexture.rgb = mix( textTexture.rgb, uTextColorAnimatable.rgb, vstep * maskTexture * ( 1.0 - uHasMultipleTextColors ) );\n + + // Draw the text as overlay above the style + gl_FragColor = ( textTexture + styleTexture * ( 1.0 - textTexture.a ) ) * uColor * vec4( mixColor, 1.0 );\n + }\n +); + +/** + * Return Property index for the given string key + * param[in] stringKey the string index key + * return the key as an index + */ + +Dali::Property::Index StringKeyToIndexKey( const std::string& stringKey ) +{ + Dali::Property::Index result = Property::INVALID_KEY; + + if( stringKey == VISUAL_TYPE ) + { + result = Toolkit::Visual::Property::TYPE; + } + else if( stringKey == TEXT_PROPERTY ) + { + result = Toolkit::TextVisual::Property::TEXT; + } + else if( stringKey == FONT_FAMILY_PROPERTY ) + { + result = Toolkit::TextVisual::Property::FONT_FAMILY; + } + else if( stringKey == FONT_STYLE_PROPERTY ) + { + result = Toolkit::TextVisual::Property::FONT_STYLE; + } + else if( stringKey == POINT_SIZE_PROPERTY ) + { + result = Toolkit::TextVisual::Property::POINT_SIZE; + } + else if( stringKey == MULTI_LINE_PROPERTY ) + { + result = Toolkit::TextVisual::Property::MULTI_LINE; + } + else if( stringKey == HORIZONTAL_ALIGNMENT_PROPERTY ) + { + result = Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT; + } + else if( stringKey == VERTICAL_ALIGNMENT_PROPERTY ) + { + result = Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT; + } + else if( stringKey == TEXT_COLOR_PROPERTY ) + { + result = Toolkit::TextVisual::Property::TEXT_COLOR; + } + else if( stringKey == ENABLE_MARKUP_PROPERTY ) + { + result = Toolkit::TextVisual::Property::ENABLE_MARKUP; + } + else if( stringKey == SHADOW_PROPERTY ) + { + result = Toolkit::TextVisual::Property::SHADOW; + } + else if( stringKey == UNDERLINE_PROPERTY ) + { + result = Toolkit::TextVisual::Property::UNDERLINE; + } + else if( stringKey == OUTLINE_PROPERTY ) + { + result = Toolkit::DevelTextVisual::Property::OUTLINE; + } + else if( stringKey == BACKGROUND_PROPERTY ) + { + result = Toolkit::DevelTextVisual::Property::BACKGROUND; + } + + return result; +} + +void TextColorConstraint( Vector4& current, const PropertyInputContainer& inputs ) +{ + Vector4 color = inputs[0]->GetVector4(); + current.r = color.r * color.a; + current.g = color.g * color.a; + current.b = color.b * color.a; + current.a = color.a; +} + +void OpacityConstraint( float& current, const PropertyInputContainer& inputs ) +{ + // Make zero if the alpha value of text color is zero to skip rendering text + if( EqualsZero( inputs[0]->GetVector4().a ) ) + { + current = 0.0f; + } + else + { + current = 1.0f; + } +} + } // unnamed namespace TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties ) @@ -147,6 +320,27 @@ TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache, const Property: return TextVisualPtr; } +void TextVisual::ConvertStringKeysToIndexKeys( Property::Map& propertyMap ) +{ + Property::Map outMap; + + for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index ) + { + const KeyValuePair& keyValue = propertyMap.GetKeyValue( index ); + + Property::Index indexKey = keyValue.first.indexKey; + + if ( keyValue.first.type == Property::Key::STRING ) + { + indexKey = StringKeyToIndexKey( keyValue.first.stringKey ); + } + + outMap.Insert( indexKey, keyValue.second ); + } + + propertyMap = outMap; +} + float TextVisual::GetHeightForWidth( float width ) { return mController->GetHeightForWidth( width ); @@ -162,7 +356,7 @@ void TextVisual::DoCreatePropertyMap( Property::Map& map ) const Property::Value value; map.Clear(); - map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::DevelVisual::TEXT ); + map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT ); std::string text; mController->GetText( text ); @@ -173,23 +367,47 @@ void TextVisual::DoCreatePropertyMap( Property::Map& map ) const GetFontStyleProperty( mController, value, Text::FontStyle::DEFAULT ); map.Insert( Toolkit::TextVisual::Property::FONT_STYLE, value ); - map.Insert( Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultPointSize() ); + map.Insert( Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ) ); map.Insert( Toolkit::TextVisual::Property::MULTI_LINE, mController->IsMultiLineEnabled() ); - map.Insert( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, GetHorizontalAlignment( mController->GetHorizontalAlignment() ) ); + map.Insert( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, mController->GetHorizontalAlignment() ); - map.Insert( Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, GetVerticalAlignment( mController->GetVerticalAlignment() ) ); + map.Insert( Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, mController->GetVerticalAlignment() ); map.Insert( Toolkit::TextVisual::Property::TEXT_COLOR, mController->GetDefaultColor() ); map.Insert( Toolkit::TextVisual::Property::ENABLE_MARKUP, mController->IsMarkupProcessorEnabled() ); + + GetShadowProperties( mController, value, Text::EffectStyle::DEFAULT ); + map.Insert( Toolkit::TextVisual::Property::SHADOW, value ); + + GetUnderlineProperties( mController, value, Text::EffectStyle::DEFAULT ); + map.Insert( Toolkit::TextVisual::Property::UNDERLINE, value ); + + GetOutlineProperties( mController, value, Text::EffectStyle::DEFAULT ); + map.Insert( Toolkit::DevelTextVisual::Property::OUTLINE, value ); + + GetBackgroundProperties( mController, value, Text::EffectStyle::DEFAULT ); + map.Insert( Toolkit::DevelTextVisual::Property::BACKGROUND, value ); } +void TextVisual::DoCreateInstancePropertyMap( Property::Map& map ) const +{ + map.Clear(); + map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT ); + std::string text; + mController->GetText( text ); + map.Insert( Toolkit::TextVisual::Property::TEXT, text ); +} + + TextVisual::TextVisual( VisualFactoryCache& factoryCache ) -: Visual::Base( factoryCache ), +: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO ), mController( Text::Controller::New() ), - mTypesetter( Text::Typesetter::New( mController->GetTextModel() ) ) + mTypesetter( Text::Typesetter::New( mController->GetTextModel() ) ), + mAnimatableTextColorPropertyIndex( Property::INVALID_INDEX ), + mRendererUpdateNeeded( false ) { } @@ -203,54 +421,14 @@ void TextVisual::DoSetProperties( const Property::Map& propertyMap ) { const KeyValuePair& keyValue = propertyMap.GetKeyValue( index ); - switch( keyValue.first.type ) + Property::Index indexKey = keyValue.first.indexKey; + + if( keyValue.first.type == Property::Key::STRING ) { - case Property::Key::INDEX: - { - DoSetProperty( keyValue.first.indexKey, keyValue.second ); - break; - } - case Property::Key::STRING: - { - if( keyValue.first.stringKey == TEXT_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::TEXT, keyValue.second ); - } - else if( keyValue.first.stringKey == FONT_FAMILY_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::FONT_FAMILY, keyValue.second ); - } - else if( keyValue.first.stringKey == FONT_STYLE_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::FONT_STYLE, keyValue.second ); - } - else if( keyValue.first.stringKey == POINT_SIZE_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::POINT_SIZE, keyValue.second ); - } - else if( keyValue.first.stringKey == MULTI_LINE_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::MULTI_LINE, keyValue.second ); - } - else if( keyValue.first.stringKey == HORIZONTAL_ALIGNMENT_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, keyValue.second ); - } - else if( keyValue.first.stringKey == VERTICAL_ALIGNMENT_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, keyValue.second ); - } - else if( keyValue.first.stringKey == TEXT_COLOR_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::TEXT_COLOR, keyValue.second ); - } - else if( keyValue.first.stringKey == ENABLE_MARKUP_PROPERTY ) - { - DoSetProperty( Toolkit::TextVisual::Property::ENABLE_MARKUP, keyValue.second ); - } - break; - } + indexKey = StringKeyToIndexKey( keyValue.first.stringKey ); } + + DoSetProperty( indexKey, keyValue.second ); } // Elide the text if it exceeds the boundaries. @@ -268,14 +446,35 @@ void TextVisual::DoSetOnStage( Actor& actor ) mControl = actor; Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); + Shader shader = GetTextShader(mFactoryCache, TextType::SINGLE_COLOR_TEXT, TextType::NO_EMOJI, TextType::NO_STYLES); - Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP ); - mFactoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader ); + mImpl->mRenderer = Renderer::New( geometry, shader ); + mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT ); - shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + // Enable the pre-multiplied alpha to improve the text quality + EnablePreMultipliedAlpha(true); - mImpl->mRenderer = Renderer::New( geometry, shader ); - mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::TEXT ); + const Vector4& defaultColor = mController->GetTextModel()->GetDefaultColor(); + Dali::Property::Index shaderTextColorIndex = mImpl->mRenderer.RegisterProperty( "uTextColorAnimatable", defaultColor ); + + if ( mAnimatableTextColorPropertyIndex != Property::INVALID_INDEX ) + { + // Create constraint for the animatable text's color Property with uTextColorAnimatable in the renderer. + if( shaderTextColorIndex != Property::INVALID_INDEX ) + { + Constraint colorConstraint = Constraint::New( mImpl->mRenderer, shaderTextColorIndex, TextColorConstraint ); + colorConstraint.AddSource( Source( actor, mAnimatableTextColorPropertyIndex ) ); + colorConstraint.Apply(); + + // Make zero if the alpha value of text color is zero to skip rendering text + Constraint opacityConstraint = Constraint::New< float >( mImpl->mRenderer, Dali::DevelRenderer::Property::OPACITY, OpacityConstraint ); + opacityConstraint.AddSource( Source( actor, mAnimatableTextColorPropertyIndex ) ); + opacityConstraint.Apply(); + } + } + + // Renderer needs textures and to be added to control + mRendererUpdateNeeded = true; UpdateRenderer(); } @@ -330,9 +529,9 @@ void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Propert case Toolkit::TextVisual::Property::POINT_SIZE: { const float pointSize = propertyValue.Get(); - if( !Equals( mController->GetDefaultPointSize(), pointSize ) ) + if( !Equals( mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) ) { - mController->SetDefaultPointSize( pointSize ); + mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE ); } break; } @@ -343,25 +542,25 @@ void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Propert } case Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT: { - Toolkit::Text::Layout::HorizontalAlignment alignment( Toolkit::Text::Layout::HORIZONTAL_ALIGN_BEGIN ); - if( Scripting::GetEnumeration< Toolkit::Text::Layout::HorizontalAlignment >( propertyValue.Get< std::string >().c_str(), - HORIZONTAL_ALIGNMENT_STRING_TABLE, - HORIZONTAL_ALIGNMENT_STRING_TABLE_COUNT, - alignment ) ) + if( mController ) { - mController->SetHorizontalAlignment( alignment ); + Text::HorizontalAlignment::Type alignment( static_cast< Text::HorizontalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set + if( Toolkit::Text::GetHorizontalAlignmentEnumeration( propertyValue, alignment ) ) + { + mController->SetHorizontalAlignment( alignment ); + } } break; } case Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT: { - Toolkit::Text::Layout::VerticalAlignment alignment( Toolkit::Text::Layout::VERTICAL_ALIGN_BOTTOM ); - if( Scripting::GetEnumeration< Toolkit::Text::Layout::VerticalAlignment >( propertyValue.Get< std::string >().c_str(), - VERTICAL_ALIGNMENT_STRING_TABLE, - VERTICAL_ALIGNMENT_STRING_TABLE_COUNT, - alignment ) ) + if( mController ) { - mController->SetVerticalAlignment( alignment ); + Toolkit::Text::VerticalAlignment::Type alignment( static_cast< Text::VerticalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set + if( Toolkit::Text::GetVerticalAlignmentEnumeration( propertyValue, alignment) ) + { + mController->SetVerticalAlignment( alignment ); + } } break; } @@ -374,6 +573,26 @@ void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Propert } break; } + case Toolkit::TextVisual::Property::SHADOW: + { + SetShadowProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + break; + } + case Toolkit::TextVisual::Property::UNDERLINE: + { + SetUnderlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + break; + } + case Toolkit::DevelTextVisual::Property::OUTLINE: + { + SetOutlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + break; + } + case Toolkit::DevelTextVisual::Property::BACKGROUND: + { + SetBackgroundProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + break; + } } } @@ -396,7 +615,10 @@ void TextVisual::UpdateRenderer() relayoutSize.width = floorf( 0.5f + ( isWidthRelative ? mImpl->mControlSize.width * mImpl->mTransform.mSize.x : mImpl->mTransform.mSize.width ) ); relayoutSize.height = floorf( 0.5f + ( isHeightRelative ? mImpl->mControlSize.height * mImpl->mTransform.mSize.y : mImpl->mTransform.mSize.height ) ); - if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) ) + std::string text; + mController->GetText( text ); + + if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) || text.empty() ) { // Removes the texture set. RemoveTextureSet(); @@ -408,13 +630,17 @@ void TextVisual::UpdateRenderer() } // Nothing else to do if the relayout size is zero. + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); return; } const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize ); - if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) ) + if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) + || mRendererUpdateNeeded ) { + mRendererUpdateNeeded = false; + // Removes the texture set. RemoveTextureSet(); @@ -427,40 +653,63 @@ void TextVisual::UpdateRenderer() if( ( relayoutSize.width > Math::MACHINE_EPSILON_1000 ) && ( relayoutSize.height > Math::MACHINE_EPSILON_1000 ) ) { - PixelData data = mTypesetter->Render( relayoutSize ); + // Check whether it is a markup text with multiple text colors + const Vector4* const colorsBuffer = mController->GetTextModel()->GetColors(); + bool hasMultipleTextColors = ( NULL != colorsBuffer ); - Vector4 atlasRect = FULL_TEXTURE_RECT; + // Check whether the text contains any color glyph + bool containsColorGlyph = false; - // Texture set not retrieved from Atlas Manager whilst pixel offset visible. + TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get(); + const Text::GlyphInfo* const glyphsBuffer = mController->GetTextModel()->GetGlyphs(); + const Text::Length numberOfGlyphs = mController->GetTextModel()->GetNumberOfGlyphs(); + for ( Text::Length glyphIndex = 0; glyphIndex < numberOfGlyphs; glyphIndex++ ) + { + // Retrieve the glyph's info. + const Text::GlyphInfo* const glyphInfo = glyphsBuffer + glyphIndex; + + // Whether the current glyph is a color one. + if( fontClient.IsColorGlyph( glyphInfo->fontId, glyphInfo->index ) ) + { + containsColorGlyph = true; + break; + } + } + + // Check whether the text contains any style colors (e.g. underline color, shadow color, etc.) + + bool shadowEnabled = false; + const Vector2& shadowOffset = mController->GetTextModel()->GetShadowOffset(); + if ( fabsf( shadowOffset.x ) > Math::MACHINE_EPSILON_1 || fabsf( shadowOffset.y ) > Math::MACHINE_EPSILON_1 ) + { + shadowEnabled = true; + } - // It may happen the image atlas can't handle a pixel data it exceeds the maximum size. - // In that case, create a texture. TODO: should tile the text. + const bool underlineEnabled = mController->GetTextModel()->IsUnderlineEnabled(); + const bool outlineEnabled = ( mController->GetTextModel()->GetOutlineWidth() > Math::MACHINE_EPSILON_1 ); + const bool backgroundEnabled = mController->GetTextModel()->IsBackgroundEnabled();; - Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, - data.GetPixelFormat(), - data.GetWidth(), - data.GetHeight() ); + const bool styleEnabled = ( shadowEnabled || underlineEnabled || outlineEnabled || backgroundEnabled ); - texture.Upload( data ); + TextureSet textureSet = GetTextTexture( relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + mImpl->mRenderer.SetTextures( textureSet ); - TextureSet textureSet = TextureSet::New(); - textureSet.SetTexture( 0u, texture ); + Shader shader = GetTextShader( mFactoryCache, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + mImpl->mRenderer.SetShader(shader); mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; - mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect ); + mImpl->mRenderer.RegisterProperty( "uHasMultipleTextColors", static_cast( hasMultipleTextColors ) ); + + mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON); //Register transform properties mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); - // Filter mode needs to be set to nearest to avoid blurry text. - Sampler sampler = Sampler::New(); - sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST ); - textureSet.SetSampler( 0u, sampler ); - - mImpl->mRenderer.SetTextures( textureSet ); - control.AddRenderer( mImpl->mRenderer ); + + // Text rendered and ready to display + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); } } } @@ -484,6 +733,149 @@ void TextVisual::RemoveTextureSet() } } +TextureSet TextVisual::GetTextTexture( const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +{ + // Filter mode needs to be set to linear to produce better quality while scaling. + Sampler sampler = Sampler::New(); + sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR ); + + TextureSet textureSet = TextureSet::New(); + + // Create RGBA texture if the text contains emojis or multiple text colors, otherwise L8 texture + Pixel::Format textPixelFormat = ( containsColorGlyph || hasMultipleTextColors ) ? Pixel::RGBA8888 : Pixel::L8; + + // Check the text direction + Toolkit::DevelText::TextDirection::Type textDirection = mController->GetTextDirection(); + + // Create a texture for the text without any styles + PixelData data = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_STYLES, false, textPixelFormat ); + + // It may happen the image atlas can't handle a pixel data it exceeds the maximum size. + // In that case, create a texture. TODO: should tile the text. + + Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, + data.GetPixelFormat(), + data.GetWidth(), + data.GetHeight() ); + + texture.Upload( data ); + + textureSet.SetTexture( 0u, texture ); + textureSet.SetSampler( 0u, sampler ); + + if ( styleEnabled ) + { + // Create RGBA texture for all the text styles (without the text itself) + PixelData styleData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888 ); + + Texture styleTexture = Texture::New( Dali::TextureType::TEXTURE_2D, + styleData.GetPixelFormat(), + styleData.GetWidth(), + styleData.GetHeight() ); + + styleTexture.Upload( styleData ); + + textureSet.SetTexture( 1u, styleTexture ); + textureSet.SetSampler( 1u, sampler ); + } + + if ( containsColorGlyph && !hasMultipleTextColors ) + { + // Create a L8 texture as a mask to avoid color glyphs (e.g. emojis) to be affected by text color animation + PixelData maskData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8 ); + + Texture maskTexture = Texture::New( Dali::TextureType::TEXTURE_2D, + maskData.GetPixelFormat(), + maskData.GetWidth(), + maskData.GetHeight() ); + + maskTexture.Upload( maskData ); + + if ( !styleEnabled ) + { + textureSet.SetTexture( 1u, maskTexture ); + textureSet.SetSampler( 1u, sampler ); + } + else + { + textureSet.SetTexture( 2u, maskTexture ); + textureSet.SetSampler( 2u, sampler ); + } + } + + return textureSet; +} + +Shader TextVisual::GetTextShader( VisualFactoryCache& factoryCache, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +{ + Shader shader; + + if( hasMultipleTextColors && !styleEnabled ) + { + // We don't animate text color if the text contains multiple colors + shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_MULTI_COLOR_TEXT ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT, shader ); + } + } + else if( hasMultipleTextColors && styleEnabled ) + { + // We don't animate text color if the text contains multiple colors + shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE, shader ); + } + } + else if( !hasMultipleTextColors && !containsColorGlyph && !styleEnabled ) + { + shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT, shader ); + } + } + else if( !hasMultipleTextColors && !containsColorGlyph && styleEnabled ) + { + shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE, shader ); + } + } + else if( !hasMultipleTextColors && containsColorGlyph && !styleEnabled ) + { + shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI, shader ); + } + } + else // if( !hasMultipleTextColors && containsColorGlyph && styleEnabled ) + { + shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI ); + shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT ); + factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI, shader ); + } + } + + return shader; +} + } // namespace Internal } // namespace Toolkit