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=21067451402ec439f26046230e92c313c128447b;hp=a3057c3172503a965969395ba5f8537a7088f815;hb=c93f6281a8bafc5b7ba5f0dcdad0eb675b8e3436;hpb=160d5d7d3f87c50540f4083ac82458309a3a4610 diff --git a/dali-toolkit/internal/visuals/text/text-visual.cpp b/dali-toolkit/internal/visuals/text/text-visual.cpp old mode 100755 new mode 100644 index a3057c3..2106745 --- a/dali-toolkit/internal/visuals/text/text-visual.cpp +++ b/dali-toolkit/internal/visuals/text/text-visual.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 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. @@ -19,185 +19,40 @@ #include // EXTERNAL INCLUDES -#include -#include -#include #include #include +#include +#include +#include #include // INTERNAL HEADER -#include -#include -#include #include +#include +#include +#include +#include +#include +#include +#include #include -#include #include +#include #include -#include -#include -#include -#include -#include +#include +#include namespace Dali { - namespace Toolkit { - namespace Internal { - namespace { -const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f ); - -const char* VERTEX_SHADER = DALI_COMPOSE_SHADER( - attribute mediump vec2 aPosition;\n - uniform highp mat4 uMvpMatrix;\n - uniform mediump vec3 uSize;\n - uniform mediump vec4 pixelArea;\n - - varying mediump vec2 vTexCoord;\n - - //Visual size and offset - uniform mediump vec2 offset;\n - uniform mediump vec2 size;\n - uniform mediump vec4 offsetSizeMode;\n - uniform mediump vec2 origin;\n - uniform mediump vec2 anchorPoint;\n - - vec4 ComputeVertexPosition()\n - {\n - vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n - vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n - return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n - }\n - - void main()\n - {\n - gl_Position = uMvpMatrix * ComputeVertexPosition();\n - vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\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 -); +const int CUSTOM_PROPERTY_COUNT(5); // anim,premul,size,offset,multicol + +const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f); /** * Return Property index for the given string key @@ -205,63 +60,63 @@ const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI = DALI_COMPOS * return the key as an index */ -Dali::Property::Index StringKeyToIndexKey( const std::string& stringKey ) +Dali::Property::Index StringKeyToIndexKey(const std::string& stringKey) { Dali::Property::Index result = Property::INVALID_KEY; - if( stringKey == VISUAL_TYPE ) + if(stringKey == VISUAL_TYPE) { result = Toolkit::Visual::Property::TYPE; } - else if( stringKey == TEXT_PROPERTY ) + else if(stringKey == TEXT_PROPERTY) { result = Toolkit::TextVisual::Property::TEXT; } - else if( stringKey == FONT_FAMILY_PROPERTY ) + else if(stringKey == FONT_FAMILY_PROPERTY) { result = Toolkit::TextVisual::Property::FONT_FAMILY; } - else if( stringKey == FONT_STYLE_PROPERTY ) + else if(stringKey == FONT_STYLE_PROPERTY) { result = Toolkit::TextVisual::Property::FONT_STYLE; } - else if( stringKey == POINT_SIZE_PROPERTY ) + else if(stringKey == POINT_SIZE_PROPERTY) { result = Toolkit::TextVisual::Property::POINT_SIZE; } - else if( stringKey == MULTI_LINE_PROPERTY ) + else if(stringKey == MULTI_LINE_PROPERTY) { result = Toolkit::TextVisual::Property::MULTI_LINE; } - else if( stringKey == HORIZONTAL_ALIGNMENT_PROPERTY ) + else if(stringKey == HORIZONTAL_ALIGNMENT_PROPERTY) { result = Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT; } - else if( stringKey == VERTICAL_ALIGNMENT_PROPERTY ) + else if(stringKey == VERTICAL_ALIGNMENT_PROPERTY) { result = Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT; } - else if( stringKey == TEXT_COLOR_PROPERTY ) + else if(stringKey == TEXT_COLOR_PROPERTY) { result = Toolkit::TextVisual::Property::TEXT_COLOR; } - else if( stringKey == ENABLE_MARKUP_PROPERTY ) + else if(stringKey == ENABLE_MARKUP_PROPERTY) { result = Toolkit::TextVisual::Property::ENABLE_MARKUP; } - else if( stringKey == SHADOW_PROPERTY ) + else if(stringKey == SHADOW_PROPERTY) { result = Toolkit::TextVisual::Property::SHADOW; } - else if( stringKey == UNDERLINE_PROPERTY ) + else if(stringKey == UNDERLINE_PROPERTY) { result = Toolkit::TextVisual::Property::UNDERLINE; } - else if( stringKey == OUTLINE_PROPERTY ) + else if(stringKey == OUTLINE_PROPERTY) { result = Toolkit::DevelTextVisual::Property::OUTLINE; } - else if( stringKey == BACKGROUND_PROPERTY ) + else if(stringKey == BACKGROUND_PROPERTY) { result = Toolkit::DevelTextVisual::Property::BACKGROUND; } @@ -269,19 +124,19 @@ Dali::Property::Index StringKeyToIndexKey( const std::string& stringKey ) return result; } -void TextColorConstraint( Vector4& current, const PropertyInputContainer& inputs ) +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; + 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 ) +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 ) ) + if(EqualsZero(inputs[0]->GetVector4().a)) { current = 0.0f; } @@ -293,195 +148,232 @@ void OpacityConstraint( float& current, const PropertyInputContainer& inputs ) } // unnamed namespace -TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties ) +TextVisualPtr TextVisual::New(VisualFactoryCache& factoryCache, TextVisualShaderFactory& shaderFactory, const Property::Map& properties) { - TextVisualPtr TextVisualPtr( new TextVisual( factoryCache ) ); - TextVisualPtr->SetProperties( properties ); - return TextVisualPtr; + TextVisualPtr textVisualPtr(new TextVisual(factoryCache, shaderFactory)); + textVisualPtr->SetProperties(properties); + textVisualPtr->Initialize(); + return textVisualPtr; } -void TextVisual::ConvertStringKeysToIndexKeys( Property::Map& propertyMap ) +Property::Map TextVisual::ConvertStringKeysToIndexKeys(const Property::Map& propertyMap) { Property::Map outMap; - for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index ) + for(Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index) { - const KeyValuePair& keyValue = propertyMap.GetKeyValue( index ); + const KeyValuePair& keyValue = propertyMap.GetKeyValue(index); Property::Index indexKey = keyValue.first.indexKey; - if ( keyValue.first.type == Property::Key::STRING ) + if(keyValue.first.type == Property::Key::STRING) { - indexKey = StringKeyToIndexKey( keyValue.first.stringKey ); + indexKey = StringKeyToIndexKey(keyValue.first.stringKey); } - outMap.Insert( indexKey, keyValue.second ); + outMap.Insert(indexKey, keyValue.second); } - propertyMap = outMap; + return outMap; } -float TextVisual::GetHeightForWidth( float width ) +float TextVisual::GetHeightForWidth(float width) { - return mController->GetHeightForWidth( width ); + return mController->GetHeightForWidth(width); } -void TextVisual::GetNaturalSize( Vector2& naturalSize ) +void TextVisual::GetNaturalSize(Vector2& naturalSize) { naturalSize = mController->GetNaturalSize().GetVectorXY(); } -void TextVisual::DoCreatePropertyMap( Property::Map& map ) const +void TextVisual::DoCreatePropertyMap(Property::Map& map) const { Property::Value value; map.Clear(); - map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT ); + map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT); std::string text; - mController->GetText( text ); - map.Insert( Toolkit::TextVisual::Property::TEXT, text ); + mController->GetText(text); + map.Insert(Toolkit::TextVisual::Property::TEXT, text); + + map.Insert(Toolkit::TextVisual::Property::FONT_FAMILY, mController->GetDefaultFontFamily()); - map.Insert( Toolkit::TextVisual::Property::FONT_FAMILY, mController->GetDefaultFontFamily() ); + GetFontStyleProperty(mController, value, Text::FontStyle::DEFAULT); + map.Insert(Toolkit::TextVisual::Property::FONT_STYLE, value); - GetFontStyleProperty( mController, value, Text::FontStyle::DEFAULT ); - map.Insert( Toolkit::TextVisual::Property::FONT_STYLE, value ); + map.Insert(Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultFontSize(Text::Controller::POINT_SIZE)); - 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::MULTI_LINE, mController->IsMultiLineEnabled() ); + map.Insert(Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, mController->GetHorizontalAlignment()); - map.Insert( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, mController->GetHorizontalAlignment() ); + map.Insert(Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, 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::TEXT_COLOR, mController->GetDefaultColor() ); + map.Insert(Toolkit::TextVisual::Property::ENABLE_MARKUP, mController->IsMarkupProcessorEnabled()); - map.Insert( Toolkit::TextVisual::Property::ENABLE_MARKUP, mController->IsMarkupProcessorEnabled() ); + GetShadowProperties(mController, value, Text::EffectStyle::DEFAULT); + map.Insert(Toolkit::TextVisual::Property::SHADOW, value); - 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); - 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); - 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); - GetBackgroundProperties( mController, value, Text::EffectStyle::DEFAULT ); - map.Insert( Toolkit::DevelTextVisual::Property::BACKGROUND, value ); + GetStrikethroughProperties(mController, value, Text::EffectStyle::DEFAULT); + map.Insert(Toolkit::DevelTextVisual::Property::STRIKETHROUGH, value); } -void TextVisual::DoCreateInstancePropertyMap( Property::Map& map ) const +void TextVisual::DoCreateInstancePropertyMap(Property::Map& map) const { map.Clear(); - map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT ); + map.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT); std::string text; - mController->GetText( text ); - map.Insert( Toolkit::TextVisual::Property::TEXT, text ); + mController->GetText(text); + map.Insert(Toolkit::TextVisual::Property::TEXT, text); } +void TextVisual::EnablePreMultipliedAlpha(bool preMultiplied) +{ + // Make always enable pre multiplied alpha whether preMultiplied value is false. + if(!preMultiplied) + { + DALI_LOG_WARNING("Note : TextVisual cannot disable PreMultipliedAlpha\n"); + } +} -TextVisual::TextVisual( VisualFactoryCache& factoryCache ) -: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO, Toolkit::Visual::TEXT ), - mController( Text::Controller::New() ), - mTypesetter( Text::Typesetter::New( mController->GetTextModel() ) ), - mAnimatableTextColorPropertyIndex( Property::INVALID_INDEX ), - mRendererUpdateNeeded( false ) +TextVisual::TextVisual(VisualFactoryCache& factoryCache, TextVisualShaderFactory& shaderFactory) +: Visual::Base(factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO, Toolkit::Visual::TEXT), + mController(Text::Controller::New()), + mTypesetter(Text::Typesetter::New(mController->GetTextModel())), + mTextVisualShaderFactory(shaderFactory), + mTextShaderFeatureCache(), + mAnimatableTextColorPropertyIndex(Property::INVALID_INDEX), + mTextColorAnimatableIndex(Property::INVALID_INDEX), + mRendererUpdateNeeded(false) { + // Enable the pre-multiplied alpha to improve the text quality + mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA; } TextVisual::~TextVisual() { } -void TextVisual::DoSetProperties( const Property::Map& propertyMap ) +void TextVisual::OnInitialize() +{ + Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY); + Shader shader = GetTextShader(mFactoryCache, TextVisualShaderFeature::FeatureBuilder()); + + mImpl->mRenderer = VisualRenderer::New(geometry, shader); + mImpl->mRenderer.ReserveCustomProperties(CUSTOM_PROPERTY_COUNT); +} + +void TextVisual::DoSetProperties(const Property::Map& propertyMap) { - for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index ) + for(Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index) { - const KeyValuePair& keyValue = propertyMap.GetKeyValue( index ); + const KeyValuePair& keyValue = propertyMap.GetKeyValue(index); Property::Index indexKey = keyValue.first.indexKey; - if( keyValue.first.type == Property::Key::STRING ) + if(keyValue.first.type == Property::Key::STRING) { - indexKey = StringKeyToIndexKey( keyValue.first.stringKey ); + indexKey = StringKeyToIndexKey(keyValue.first.stringKey); } - DoSetProperty( indexKey, keyValue.second ); + DoSetProperty(indexKey, keyValue.second); } // Elide the text if it exceeds the boundaries. - mController->SetTextElideEnabled( true ); + mController->SetTextElideEnabled(true); // Retrieve the layout engine to set the cursor's width. Text::Layout::Engine& engine = mController->GetLayoutEngine(); // Sets 0 as cursor's width. - engine.SetCursorWidth( 0u ); // Do not layout space for the cursor. + engine.SetCursorWidth(0u); // Do not layout space for the cursor. } -void TextVisual::DoSetOnStage( Actor& actor ) +void TextVisual::DoSetOnScene(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); - - mImpl->mRenderer = Renderer::New( geometry, shader ); - mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT ); - - // Enable the pre-multiplied alpha to improve the text quality - EnablePreMultipliedAlpha(true); + mImpl->mRenderer.SetProperty(Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT); const Vector4& defaultColor = mController->GetTextModel()->GetDefaultColor(); - Dali::Property::Index shaderTextColorIndex = mImpl->mRenderer.RegisterProperty( "uTextColorAnimatable", defaultColor ); + if(mTextColorAnimatableIndex == Property::INVALID_INDEX) + { + mTextColorAnimatableIndex = mImpl->mRenderer.RegisterUniqueProperty("uTextColorAnimatable", defaultColor); + } + else + { + mImpl->mRenderer.SetProperty(mTextColorAnimatableIndex, defaultColor); + } - if ( mAnimatableTextColorPropertyIndex != Property::INVALID_INDEX ) + if(mAnimatableTextColorPropertyIndex != Property::INVALID_INDEX) { // Create constraint for the animatable text's color Property with uTextColorAnimatable in the renderer. - if( shaderTextColorIndex != Property::INVALID_INDEX ) + if(mTextColorAnimatableIndex != 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(); + if(!mColorConstraint) + { + mColorConstraint = Constraint::New(mImpl->mRenderer, mTextColorAnimatableIndex, TextColorConstraint); + mColorConstraint.AddSource(Source(actor, mAnimatableTextColorPropertyIndex)); + } + mColorConstraint.Apply(); } + + // Make zero if the alpha value of text color is zero to skip rendering text + if(!mOpacityConstraint) + { + // VisualRenderer::Property::OPACITY uses same animatable property internally. + mOpacityConstraint = Constraint::New(mImpl->mRenderer, Dali::DevelRenderer::Property::OPACITY, OpacityConstraint); + mOpacityConstraint.AddSource(Source(actor, mAnimatableTextColorPropertyIndex)); + } + mOpacityConstraint.Apply(); } // Renderer needs textures and to be added to control mRendererUpdateNeeded = true; - mRendererList.push_back( mImpl->mRenderer ); - UpdateRenderer(); } -void TextVisual::RemoveRenderer( Actor& actor ) +void TextVisual::RemoveRenderer(Actor& actor) { - for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter) + for(RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter) { Renderer renderer = (*iter); - if( renderer ) + if(renderer) { // Removes the renderer from the actor. - actor.RemoveRenderer( renderer ); + actor.RemoveRenderer(renderer); } } // Clear the renderer list mRendererList.clear(); } -void TextVisual::DoSetOffStage( Actor& actor ) +void TextVisual::DoSetOffScene(Actor& actor) { - RemoveRenderer( actor ); + if(mColorConstraint) + { + mColorConstraint.Remove(); + } + if(mOpacityConstraint) + { + mOpacityConstraint.Remove(); + } - // Resets the renderer. - mImpl->mRenderer.Reset(); + RemoveRenderer(actor); // Resets the control handle. mControl.Reset(); @@ -492,96 +384,101 @@ void TextVisual::OnSetTransform() UpdateRenderer(); } -void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue ) +void TextVisual::DoSetProperty(Dali::Property::Index index, const Dali::Property::Value& propertyValue) { - switch( index ) + switch(index) { case Toolkit::TextVisual::Property::ENABLE_MARKUP: { const bool enableMarkup = propertyValue.Get(); - mController->SetMarkupProcessorEnabled( enableMarkup ); + mController->SetMarkupProcessorEnabled(enableMarkup); break; } case Toolkit::TextVisual::Property::TEXT: { - mController->SetText( propertyValue.Get() ); + mController->SetText(propertyValue.Get()); break; } case Toolkit::TextVisual::Property::FONT_FAMILY: { - SetFontFamilyProperty( mController, propertyValue ); + SetFontFamilyProperty(mController, propertyValue); break; } case Toolkit::TextVisual::Property::FONT_STYLE: { - SetFontStyleProperty( mController, propertyValue, Text::FontStyle::DEFAULT ); + SetFontStyleProperty(mController, propertyValue, Text::FontStyle::DEFAULT); break; } case Toolkit::TextVisual::Property::POINT_SIZE: { const float pointSize = propertyValue.Get(); - if( !Equals( mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) ) + if(!Equals(mController->GetDefaultFontSize(Text::Controller::POINT_SIZE), pointSize)) { - mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE ); + mController->SetDefaultFontSize(pointSize, Text::Controller::POINT_SIZE); } break; } case Toolkit::TextVisual::Property::MULTI_LINE: { - mController->SetMultiLineEnabled( propertyValue.Get() ); + mController->SetMultiLineEnabled(propertyValue.Get()); break; } case Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT: { - if( mController ) + if(mController) { - 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 ) ) + Text::HorizontalAlignment::Type alignment(static_cast(-1)); // Set to invalid value to ensure a valid mode does get set + if(Toolkit::Text::GetHorizontalAlignmentEnumeration(propertyValue, alignment)) { - mController->SetHorizontalAlignment( alignment ); + mController->SetHorizontalAlignment(alignment); } } break; } case Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT: { - if( mController ) + if(mController) { - 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) ) + Toolkit::Text::VerticalAlignment::Type alignment(static_cast(-1)); // Set to invalid value to ensure a valid mode does get set + if(Toolkit::Text::GetVerticalAlignmentEnumeration(propertyValue, alignment)) { - mController->SetVerticalAlignment( alignment ); + mController->SetVerticalAlignment(alignment); } } break; } case Toolkit::TextVisual::Property::TEXT_COLOR: { - const Vector4& textColor = propertyValue.Get< Vector4 >(); - if( mController->GetDefaultColor() != textColor ) + const Vector4& textColor = propertyValue.Get(); + if(mController->GetDefaultColor() != textColor) { - mController->SetDefaultColor( textColor ); + mController->SetDefaultColor(textColor); } break; } case Toolkit::TextVisual::Property::SHADOW: { - SetShadowProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + SetShadowProperties(mController, propertyValue, Text::EffectStyle::DEFAULT); break; } case Toolkit::TextVisual::Property::UNDERLINE: { - SetUnderlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + SetUnderlineProperties(mController, propertyValue, Text::EffectStyle::DEFAULT); break; } case Toolkit::DevelTextVisual::Property::OUTLINE: { - SetOutlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + SetOutlineProperties(mController, propertyValue, Text::EffectStyle::DEFAULT); break; } case Toolkit::DevelTextVisual::Property::BACKGROUND: { - SetBackgroundProperties( mController, propertyValue, Text::EffectStyle::DEFAULT ); + SetBackgroundProperties(mController, propertyValue, Text::EffectStyle::DEFAULT); + break; + } + case Toolkit::DevelTextVisual::Property::STRIKETHROUGH: + { + SetStrikethroughProperties(mController, propertyValue, Text::EffectStyle::DEFAULT); break; } } @@ -590,7 +487,7 @@ void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Propert void TextVisual::UpdateRenderer() { Actor control = mControl.GetHandle(); - if( !control ) + if(!control) { // Nothing to do. return; @@ -599,58 +496,57 @@ void TextVisual::UpdateRenderer() // Calculates the size to be used to relayout. Vector2 relayoutSize; - const bool isWidthRelative = fabsf( mImpl->mTransform.mOffsetSizeMode.z ) < Math::MACHINE_EPSILON_1000; - const bool isHeightRelative = fabsf( mImpl->mTransform.mOffsetSizeMode.w ) < Math::MACHINE_EPSILON_1000; + const bool isWidthRelative = fabsf(mImpl->mTransform.mOffsetSizeMode.z) < Math::MACHINE_EPSILON_1000; + const bool isHeightRelative = fabsf(mImpl->mTransform.mOffsetSizeMode.w) < Math::MACHINE_EPSILON_1000; // Round the size and offset to avoid pixel alignement issues. - 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 ) ); + 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)); std::string text; - mController->GetText( text ); + mController->GetText(text); - if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) || text.empty() ) + if((fabsf(relayoutSize.width) < Math::MACHINE_EPSILON_1000) || (fabsf(relayoutSize.height) < Math::MACHINE_EPSILON_1000) || text.empty()) { // Remove the texture set and any renderer previously set. - RemoveRenderer( control ); + RemoveRenderer(control); // Nothing else to do if the relayout size is zero. - ResourceReady( Toolkit::Visual::ResourceStatus::READY ); + ResourceReady(Toolkit::Visual::ResourceStatus::READY); return; } - Dali::LayoutDirection::Type layoutDirection = static_cast( control.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get() ); + Dali::LayoutDirection::Type layoutDirection = mController->GetLayoutDirection(control); - const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize, layoutDirection ); + const Text::Controller::UpdateTextType updateTextType = mController->Relayout(relayoutSize, layoutDirection); - if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType ) - || mRendererUpdateNeeded ) + if(Text::Controller::NONE_UPDATED != (Text::Controller::MODEL_UPDATED & updateTextType) || mRendererUpdateNeeded) { mRendererUpdateNeeded = false; // Remove the texture set and any renderer previously set. - RemoveRenderer( control ); + RemoveRenderer(control); - if( ( relayoutSize.width > Math::MACHINE_EPSILON_1000 ) && - ( relayoutSize.height > Math::MACHINE_EPSILON_1000 ) ) + if((relayoutSize.width > Math::MACHINE_EPSILON_1000) && + (relayoutSize.height > Math::MACHINE_EPSILON_1000)) { // Check whether it is a markup text with multiple text colors - const Vector4* const colorsBuffer = mController->GetTextModel()->GetColors(); - bool hasMultipleTextColors = ( NULL != colorsBuffer ); + const Vector4* const colorsBuffer = mController->GetTextModel()->GetColors(); + bool hasMultipleTextColors = (NULL != colorsBuffer); // Check whether the text contains any color glyph bool containsColorGlyph = false; - 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++ ) + 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 ) ) + if(fontClient.IsColorGlyph(glyphInfo->fontId, glyphInfo->index)) { containsColorGlyph = true; break; @@ -659,191 +555,210 @@ void TextVisual::UpdateRenderer() // 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 ) + 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; } - const bool underlineEnabled = mController->GetTextModel()->IsUnderlineEnabled(); - const bool outlineEnabled = ( mController->GetTextModel()->GetOutlineWidth() > Math::MACHINE_EPSILON_1 ); - const bool backgroundEnabled = mController->GetTextModel()->IsBackgroundEnabled();; - - const bool styleEnabled = ( shadowEnabled || underlineEnabled || outlineEnabled || backgroundEnabled ); + const bool underlineEnabled = mController->GetTextModel()->IsUnderlineEnabled(); + const bool outlineEnabled = (mController->GetTextModel()->GetOutlineWidth() > Math::MACHINE_EPSILON_1); + const bool backgroundEnabled = mController->GetTextModel()->IsBackgroundEnabled(); + const bool markupProcessorEnabled = mController->IsMarkupProcessorEnabled(); + const bool strikethroughEnabled = mController->GetTextModel()->IsStrikethroughEnabled(); + const bool styleEnabled = (shadowEnabled || underlineEnabled || outlineEnabled || backgroundEnabled || markupProcessorEnabled || strikethroughEnabled); + const bool isOverlayStyle = underlineEnabled || strikethroughEnabled; - AddRenderer( control, relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + AddRenderer(control, relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled, isOverlayStyle); // Text rendered and ready to display - ResourceReady( Toolkit::Visual::ResourceStatus::READY ); + ResourceReady(Toolkit::Visual::ResourceStatus::READY); } } } -void TextVisual::AddTexture( TextureSet& textureSet, PixelData& data, Sampler& sampler, unsigned int textureSetIndex ) +void TextVisual::AddTexture(TextureSet& textureSet, PixelData& data, Sampler& sampler, unsigned int textureSetIndex) { - Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, - data.GetPixelFormat(), - data.GetWidth(), - data.GetHeight() ); - texture.Upload( data ); - - textureSet.SetTexture( textureSetIndex, texture ); - textureSet.SetSampler( textureSetIndex, sampler ); + Texture texture = Texture::New(Dali::TextureType::TEXTURE_2D, + data.GetPixelFormat(), + data.GetWidth(), + data.GetHeight()); + texture.Upload(data); + + textureSet.SetTexture(textureSetIndex, texture); + textureSet.SetSampler(textureSetIndex, sampler); } -PixelData TextVisual::ConvertToPixelData( unsigned char* buffer, int width, int height, int offsetPosition, const Pixel::Format textPixelFormat ) +PixelData TextVisual::ConvertToPixelData(unsigned char* buffer, int width, int height, int offsetPosition, const Pixel::Format textPixelFormat) { - int bpp = Pixel::GetBytesPerPixel( textPixelFormat ); - unsigned int bufferSize = width * height * bpp; - unsigned char* dstBuffer = static_cast( malloc ( bufferSize ) ); - memcpy( dstBuffer, buffer + offsetPosition * bpp, bufferSize ); - PixelData pixelData = Dali::PixelData::New( dstBuffer, - bufferSize, - width, - height, - textPixelFormat, - Dali::PixelData::FREE ); + int bpp = Pixel::GetBytesPerPixel(textPixelFormat); + unsigned int bufferSize = width * height * bpp; + unsigned char* dstBuffer = static_cast(malloc(bufferSize)); + memcpy(dstBuffer, buffer + offsetPosition * bpp, bufferSize); + PixelData pixelData = Dali::PixelData::New(dstBuffer, + bufferSize, + width, + height, + textPixelFormat, + Dali::PixelData::FREE); return pixelData; } -void TextVisual::CreateTextureSet( TilingInfo& info, Renderer& renderer, Sampler& sampler, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +void TextVisual::CreateTextureSet(TilingInfo& info, VisualRenderer& renderer, Sampler& sampler) { - - TextureSet textureSet = TextureSet::New(); + TextureSet textureSet = TextureSet::New(); unsigned int textureSetIndex = 0u; // Convert the buffer to pixel data to make it a texture. - if( info.textBuffer ) + + if(info.textBuffer) { - PixelData data = ConvertToPixelData( info.textBuffer, info.width, info.height, info.offsetPosition, info.textPixelFormat ); - AddTexture( textureSet, data, sampler, textureSetIndex ); + PixelData data = ConvertToPixelData(info.textBuffer, info.width, info.height, info.offsetPosition, info.textPixelFormat); + AddTexture(textureSet, data, sampler, textureSetIndex); ++textureSetIndex; } - if( styleEnabled && info.styleBuffer ) + if(mTextShaderFeatureCache.IsEnabledStyle() && info.styleBuffer) { - PixelData styleData = ConvertToPixelData( info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888 ); - AddTexture( textureSet, styleData, sampler, textureSetIndex ); + PixelData styleData = ConvertToPixelData(info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888); + AddTexture(textureSet, styleData, sampler, textureSetIndex); ++textureSetIndex; } - if( containsColorGlyph && !hasMultipleTextColors && info.maskBuffer ) + if(mTextShaderFeatureCache.IsEnabledOverlay() && info.overlayStyleBuffer) { - PixelData maskData = ConvertToPixelData( info.maskBuffer, info.width, info.height, info.offsetPosition, Pixel::L8 ); - AddTexture( textureSet, maskData, sampler, textureSetIndex ); + PixelData overlayStyleData = ConvertToPixelData(info.overlayStyleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888); + AddTexture(textureSet, overlayStyleData, sampler, textureSetIndex); + ++textureSetIndex; + } + + if(mTextShaderFeatureCache.IsEnabledEmoji() && !mTextShaderFeatureCache.IsEnabledMultiColor() && info.maskBuffer) + { + PixelData maskData = ConvertToPixelData(info.maskBuffer, info.width, info.height, info.offsetPosition, Pixel::L8); + AddTexture(textureSet, maskData, sampler, textureSetIndex); } - renderer.SetTextures( textureSet ); + renderer.SetTextures(textureSet); //Register transform properties - mImpl->mTransform.RegisterUniforms( renderer, Direction::LEFT_TO_RIGHT ); + mImpl->mTransform.SetUniforms(renderer, Direction::LEFT_TO_RIGHT); // Enable the pre-multiplied alpha to improve the text quality - renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true ); - renderer.RegisterProperty( PREMULTIPLIED_ALPHA, 1.0f ); + renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true); + renderer.RegisterProperty(PREMULTIPLIED_ALPHA, 1.0f); // Set size and offset for the tiling. - renderer.RegisterProperty( SIZE, Vector2( info.width, info.height ) ); - renderer.RegisterProperty( OFFSET, Vector2( info.offSet.x, info.offSet.y ) ); - renderer.RegisterProperty( "uHasMultipleTextColors", static_cast( hasMultipleTextColors ) ); - renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON); + renderer.SetProperty(VisualRenderer::Property::TRANSFORM_SIZE, Vector2(info.width, info.height)); + renderer.SetProperty(VisualRenderer::Property::TRANSFORM_OFFSET, Vector2(info.offSet.x, info.offSet.y)); + renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); + renderer.RegisterProperty("uHasMultipleTextColors", static_cast(mTextShaderFeatureCache.IsEnabledMultiColor())); - mRendererList.push_back( renderer ); + mRendererList.push_back(renderer); } - -void TextVisual::AddRenderer( Actor& actor, const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +void TextVisual::AddRenderer(Actor& actor, const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled, bool isOverlayStyle) { - Shader shader = GetTextShader( mFactoryCache, hasMultipleTextColors, containsColorGlyph, styleEnabled ); - mImpl->mRenderer.SetShader( shader ); + Shader shader = GetTextShader(mFactoryCache, TextVisualShaderFeature::FeatureBuilder().EnableMultiColor(hasMultipleTextColors).EnableEmoji(containsColorGlyph).EnableStyle(styleEnabled).EnableOverlay(isOverlayStyle)); + mImpl->mRenderer.SetShader(shader); // Get the maximum size. const int maxTextureSize = Dali::GetMaxTextureSize(); // No tiling required. Use the default renderer. - if( size.height < maxTextureSize ) + if(size.height < maxTextureSize) { - TextureSet textureSet = GetTextTexture( size, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + TextureSet textureSet = GetTextTexture(size); - mImpl->mRenderer.SetTextures( textureSet ); + mImpl->mRenderer.SetTextures(textureSet); //Register transform properties - mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); - mImpl->mRenderer.RegisterProperty( "uHasMultipleTextColors", static_cast( hasMultipleTextColors ) ); - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON); + mImpl->mTransform.SetUniforms(mImpl->mRenderer, Direction::LEFT_TO_RIGHT); + mImpl->mRenderer.RegisterProperty("uHasMultipleTextColors", static_cast(hasMultipleTextColors)); + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); - mRendererList.push_back( mImpl->mRenderer ); + mRendererList.push_back(mImpl->mRenderer); } // If the pixel data exceeds the maximum size, tiling is required. else { // Filter mode needs to be set to linear to produce better quality while scaling. Sampler sampler = Sampler::New(); - sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR ); + sampler.SetFilterMode(FilterMode::LINEAR, FilterMode::LINEAR); // Create RGBA texture if the text contains emojis or multiple text colors, otherwise L8 texture - Pixel::Format textPixelFormat = ( containsColorGlyph || hasMultipleTextColors ) ? Pixel::RGBA8888 : Pixel::L8; + 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 ); + PixelData data = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_NO_STYLES, false, textPixelFormat); - int verifiedWidth = data.GetWidth(); + int verifiedWidth = data.GetWidth(); int verifiedHeight = data.GetHeight(); // Set information for creating textures. - TilingInfo info( verifiedWidth, maxTextureSize, textPixelFormat ); + TilingInfo info(verifiedWidth, maxTextureSize, textPixelFormat); // Get the buffer of text. - Dali::DevelPixelData::PixelDataBuffer textPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( data ); - info.textBuffer = textPixelData.buffer; + Dali::DevelPixelData::PixelDataBuffer textPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer(data); + info.textBuffer = textPixelData.buffer; - if( styleEnabled ) + if(mTextShaderFeatureCache.IsEnabledStyle()) { // 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 ); - Dali::DevelPixelData::PixelDataBuffer stylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( styleData ); - info.styleBuffer = stylePixelData.buffer; + PixelData styleData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888); + Dali::DevelPixelData::PixelDataBuffer stylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer(styleData); + info.styleBuffer = stylePixelData.buffer; } - if ( containsColorGlyph && !hasMultipleTextColors ) + if(mTextShaderFeatureCache.IsEnabledOverlay()) + { + // Create RGBA texture for all the overlay styles + PixelData overlayStyleData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_OVERLAY_STYLE, false, Pixel::RGBA8888); + Dali::DevelPixelData::PixelDataBuffer overlayStylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer(overlayStyleData); + info.overlayStyleBuffer = overlayStylePixelData.buffer; + } + + if(mTextShaderFeatureCache.IsEnabledEmoji() && !mTextShaderFeatureCache.IsEnabledMultiColor()) { // 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 ); - Dali::DevelPixelData::PixelDataBuffer maskPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( maskData ); - info.maskBuffer = maskPixelData.buffer; + PixelData maskData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8); + Dali::DevelPixelData::PixelDataBuffer maskPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer(maskData); + info.maskBuffer = maskPixelData.buffer; } // Get the current offset for recalculate the offset when tiling. Property::Map retMap; - mImpl->mTransform.GetPropertyMap( retMap ); - Vector2 offSet = retMap.Find( Dali::Toolkit::Visual::Transform::Property::OFFSET )->Get< Vector2 >(); - info.offSet = offSet; + mImpl->mTransform.GetPropertyMap(retMap); + Property::Value* offsetValue = retMap.Find(Dali::Toolkit::Visual::Transform::Property::OFFSET); + if(offsetValue) + { + offsetValue->Get(info.offSet); + } // Create a textureset in the default renderer. - CreateTextureSet( info, mImpl->mRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + CreateTextureSet(info, mImpl->mRenderer, sampler); verifiedHeight -= maxTextureSize; - Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); + Geometry geometry = mFactoryCache.GetGeometry(VisualFactoryCache::QUAD_GEOMETRY); int offsetPosition = verifiedWidth * maxTextureSize; // Create a renderer by cutting maxTextureSize. - while( verifiedHeight > 0 ) + while(verifiedHeight > 0) { - Renderer tilingRenderer = Renderer::New( geometry, shader ); - tilingRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT ); + VisualRenderer tilingRenderer = VisualRenderer::New(geometry, shader); + tilingRenderer.SetProperty(Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT); // New offset position of buffer for tiling. info.offsetPosition += offsetPosition; // New height for tiling. - info.height = ( verifiedHeight - maxTextureSize ) > 0 ? maxTextureSize : verifiedHeight; + info.height = (verifiedHeight - maxTextureSize) > 0 ? maxTextureSize : verifiedHeight; // New offset for tiling. info.offSet.y += maxTextureSize; // Create a textureset int the new tiling renderer. - CreateTextureSet( info, tilingRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + CreateTextureSet(info, tilingRenderer, sampler); verifiedHeight -= maxTextureSize; } @@ -851,128 +766,99 @@ void TextVisual::AddRenderer( Actor& actor, const Vector2& size, bool hasMultipl mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; - for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter) + const Vector4& defaultColor = mController->GetTextModel()->GetDefaultColor(); + + for(RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter) { Renderer renderer = (*iter); - if( renderer ) + if(renderer) { - actor.AddRenderer( renderer ); + actor.AddRenderer(renderer); + + if(renderer != mImpl->mRenderer) + { + // Set constraint for text label's color for non-default renderers. + if(mAnimatableTextColorPropertyIndex != Property::INVALID_INDEX) + { + // Register unique property, or get property for default renderer. + Property::Index index = renderer.RegisterUniqueProperty("uTextColorAnimatable", defaultColor); + + // Create constraint for the animatable text's color Property with uTextColorAnimatable in the renderer. + if(index != Property::INVALID_INDEX) + { + Constraint colorConstraint = Constraint::New(renderer, index, TextColorConstraint); + colorConstraint.AddSource(Source(actor, mAnimatableTextColorPropertyIndex)); + colorConstraint.Apply(); + } + + // Make zero if the alpha value of text color is zero to skip rendering text + // VisualRenderer::Property::OPACITY uses same animatable property internally. + Constraint opacityConstraint = Constraint::New(renderer, Dali::DevelRenderer::Property::OPACITY, OpacityConstraint); + opacityConstraint.AddSource(Source(actor, mAnimatableTextColorPropertyIndex)); + opacityConstraint.Apply(); + } + } } } } - -TextureSet TextVisual::GetTextTexture( const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +TextureSet TextVisual::GetTextTexture(const Vector2& size) { // Filter mode needs to be set to linear to produce better quality while scaling. Sampler sampler = Sampler::New(); - sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR ); + 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; + Pixel::Format textPixelFormat = (mTextShaderFeatureCache.IsEnabledEmoji() || mTextShaderFeatureCache.IsEnabledMultiColor()) ? 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 ); + 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. unsigned int textureSetIndex = 0u; - - AddTexture( textureSet, data, sampler, textureSetIndex ); + AddTexture(textureSet, data, sampler, textureSetIndex); ++textureSetIndex; - if ( styleEnabled ) + if(mTextShaderFeatureCache.IsEnabledStyle()) { - // 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 ); + // Create RGBA texture for all the text styles that render in the background (without the text itself) + PixelData styleData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888); + AddTexture(textureSet, styleData, sampler, textureSetIndex); + ++textureSetIndex; + } - AddTexture( textureSet, styleData, sampler, textureSetIndex ); + if(mTextShaderFeatureCache.IsEnabledOverlay()) + { + // Create RGBA texture for overlay styles such as underline and strikethrough (without the text itself) + PixelData overlayStyleData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_OVERLAY_STYLE, false, Pixel::RGBA8888); + AddTexture(textureSet, overlayStyleData, sampler, textureSetIndex); ++textureSetIndex; } - if ( containsColorGlyph && !hasMultipleTextColors ) + if(mTextShaderFeatureCache.IsEnabledEmoji() && !mTextShaderFeatureCache.IsEnabledMultiColor()) { // 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 ); + PixelData maskData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8); - AddTexture( textureSet, maskData, sampler, textureSetIndex ); + AddTexture(textureSet, maskData, sampler, textureSetIndex); } return textureSet; } -Shader TextVisual::GetTextShader( VisualFactoryCache& factoryCache, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +Shader TextVisual::GetTextShader(VisualFactoryCache& factoryCache, const TextVisualShaderFeature::FeatureBuilder& featureBuilder) { - 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 ); - } - } + // Cache feature builder informations. + mTextShaderFeatureCache = featureBuilder; + Shader shader = mTextVisualShaderFactory.GetShader(factoryCache, mTextShaderFeatureCache); + shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT); return shader; }