From 1af4cb78028c7aae2f0df9efd0c52d6cd9bbabaa Mon Sep 17 00:00:00 2001 From: Joogab Yun Date: Mon, 13 Apr 2020 10:04:47 +0900 Subject: [PATCH] text tiling If the length of text is very long and exceeds maxTextureSize, it cannot be displayed on the screen. So tiling is required. I implement tiling by attaching multiple renderers. And the MAX_TEXT_LENGTH limit is removed. sample) std::ifstream file; file.open(PATH[0]); std::stringstream ss; ss << file.rdbuf(); file.close(); ScrollView scroller = ScrollView::New(); scroller.SetPosition( 100.f, 100.f); scroller.SetSize(500.f, 1000.f); scroller.SetAnchorPoint(AnchorPoint::TOP_LEFT); scroller.SetParentOrigin(ParentOrigin::TOP_LEFT); scroller.SetAxisAutoLock(true); TextLabel textLabel = TextLabel::New( ); textLabel.SetProperty( TextLabel::Property::TEXT, ss.str() ); textLabel.SetAnchorPoint( AnchorPoint::TOP_LEFT ); textLabel.SetParentOrigin(ParentOrigin::TOP_LEFT); textLabel.SetProperty( TextLabel::Property::VERTICAL_ALIGNMENT, "TOP" ); textLabel.SetProperty( TextLabel::Property::MULTI_LINE, true ); textLabel.SetProperty( TextLabel::Property::ELLIPSIS, false ); textLabel.SetProperty( TextLabel::Property::ENABLE_MARKUP, true ); textLabel.SetProperty( TextLabel::Property::POINT_SIZE, 16); textLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE ); scroller.Add( textLabel ); stage.Add( scroller ); Change-Id: I65082244a801ba697fd9ab0b598c82e702c2a948 --- .../utc-Dali-Text-Controller.cpp | 29 --- .../src/dali-toolkit/utc-Dali-TextLabel.cpp | 46 ++++ dali-toolkit/internal/text/text-controller.cpp | 10 +- dali-toolkit/internal/visuals/text/text-visual.cpp | 285 +++++++++++++++------ dali-toolkit/internal/visuals/text/text-visual.h | 91 ++++++- 5 files changed, 339 insertions(+), 122 deletions(-) mode change 100644 => 100755 dali-toolkit/internal/visuals/text/text-visual.h diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp index 7275618..3e53b67 100755 --- a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp +++ b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp @@ -1151,35 +1151,6 @@ int UtcDaliTextControllerSelectEvent(void) } -int UtcDaliTextControllerMaxLengthSetText(void) -{ - tet_infoline(" UtcDaliTextControllerMaxLengthSetText"); - ToolkitTestApplication application; - - // Creates a text controller. - ControllerPtr controller = Controller::New(); - - ConfigureTextLabel( controller ); - - const Length MAX_TEXT_LENGTH = 1024u * 32u; - - // make over length world - int maxLength = ( 1024u * 32u ) + 10u; - char world[maxLength] = { 'a' }; - - // Set the text - std::string text( world, maxLength ); - controller->SetText( text ); - - // check text length - controller->GetText( text ); - Length textSize = text.size(); - - DALI_TEST_EQUALS( MAX_TEXT_LENGTH, textSize, TEST_LOCATION ); - - END_TEST; -} - int UtcDaliTextControllerRemoveTextChangeEventData(void) { tet_infoline(" UtcDaliTextControllerRemoveTextChangeEventData"); diff --git a/automated-tests/src/dali-toolkit/utc-Dali-TextLabel.cpp b/automated-tests/src/dali-toolkit/utc-Dali-TextLabel.cpp index d8c5f70..9f9ce5f 100755 --- a/automated-tests/src/dali-toolkit/utc-Dali-TextLabel.cpp +++ b/automated-tests/src/dali-toolkit/utc-Dali-TextLabel.cpp @@ -26,6 +26,7 @@ #include #include #include +#include #include using namespace Dali; @@ -1535,3 +1536,48 @@ int UtcDaliToolkitTextlabelTextFit(void) END_TEST; } + +int UtcDaliToolkitTextlabelMaxTextureSet(void) +{ + ToolkitTestApplication application; + tet_infoline(" UtcDaliToolkitTextlabelMaxTextureSet"); + + DevelText::BitmapFontDescription fontDescription; + fontDescription.name = "Digits"; + fontDescription.glyphs.push_back( { TEST_RESOURCE_DIR "/fonts/bitmap/u0030.png", ":", 200.f, 0.f } ); + + TextAbstraction::BitmapFont bitmapFont; + DevelText::CreateBitmapFont( fontDescription, bitmapFont ); + + TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get(); + fontClient.GetFontId( bitmapFont ); + + TextLabel label = TextLabel::New(); + label.SetProperty( TextLabel::Property::FONT_FAMILY, "Digits" ); + label.SetProperty( TextLabel::Property::ENABLE_MARKUP, true ); + label.SetProperty( TextLabel::Property::TEXT, ":This is a long sample text made to allow max texture size to be exceeded." ); + label.SetProperty( TextLabel::Property::POINT_SIZE, 200.f ); + label.SetProperty( TextLabel::Property::MULTI_LINE, true ); + + Property::Map underlineMapSet; + underlineMapSet.Clear(); + underlineMapSet.Insert( "enable", true ); + underlineMapSet.Insert( "color", Color::RED ); + underlineMapSet.Insert( "height", 1 ); + label.SetProperty( TextLabel::Property::UNDERLINE, underlineMapSet ); + label.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE ); + + Stage::GetCurrent().Add( label ); + + application.SendNotification(); + application.Render(); + + const int maxTextureSize = Dali::GetMaxTextureSize(); + // Whether the rendered text is greater than maxTextureSize + DALI_TEST_CHECK( label.GetCurrentSize().height > maxTextureSize ); + + // Check if the number of renderers is greater than 1. + DALI_TEST_CHECK( label.GetRendererCount() > 1u ); + + END_TEST; +} diff --git a/dali-toolkit/internal/text/text-controller.cpp b/dali-toolkit/internal/text/text-controller.cpp index 0407147..8aaefae 100755 --- a/dali-toolkit/internal/text/text-controller.cpp +++ b/dali-toolkit/internal/text/text-controller.cpp @@ -62,7 +62,6 @@ const char * const PLACEHOLDER_FONT_STYLE = "fontStyle"; const char * const PLACEHOLDER_POINT_SIZE = "pointSize"; const char * const PLACEHOLDER_PIXEL_SIZE = "pixelSize"; const char * const PLACEHOLDER_ELLIPSIS = "ellipsis"; -const unsigned int MAX_TEXT_LENGTH = 1024u * 32u; float ConvertToEven( float value ) { @@ -321,7 +320,7 @@ bool Controller::IsSmoothHandlePanEnabled() const void Controller::SetMaximumNumberOfCharacters( Length maxCharacters ) { - mImpl->mMaximumNumberOfCharacters = std::min( maxCharacters, MAX_TEXT_LENGTH ); + mImpl->mMaximumNumberOfCharacters = maxCharacters; } int Controller::GetMaximumNumberOfCharacters() @@ -702,13 +701,6 @@ void Controller::SetText( const std::string& text ) utf8 = reinterpret_cast( text.c_str() ); } - // Limit the text size. If the text size is too large, crash or deadlock will occur. - if( textSize > MAX_TEXT_LENGTH ) - { - DALI_LOG_WARNING( "The text size is too large(%d), limit the length to 32,768u\n", textSize ); - textSize = MAX_TEXT_LENGTH; - } - // Convert text into UTF-32 Vector& utf32Characters = mImpl->mModel->mLogicalModel->mText; utf32Characters.Resize( textSize ); diff --git a/dali-toolkit/internal/visuals/text/text-visual.cpp b/dali-toolkit/internal/visuals/text/text-visual.cpp index e0b16e9..9ddbf3b 100755 --- a/dali-toolkit/internal/visuals/text/text-visual.cpp +++ b/dali-toolkit/internal/visuals/text/text-visual.cpp @@ -22,6 +22,9 @@ #include #include #include +#include +#include +#include // INTERNAL HEADER #include @@ -453,21 +456,32 @@ void TextVisual::DoSetOnStage( Actor& actor ) // Renderer needs textures and to be added to control mRendererUpdateNeeded = true; + mRendererList.push_back( mImpl->mRenderer ); + UpdateRenderer(); } -void TextVisual::DoSetOffStage( Actor& actor ) +void TextVisual::RemoveRenderer( Actor& actor ) { - if( mImpl->mRenderer ) + for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter) { - // Removes the renderer from the actor. - actor.RemoveRenderer( mImpl->mRenderer ); + Renderer renderer = (*iter); + if( renderer ) + { + // Removes the renderer from the actor. + actor.RemoveRenderer( renderer ); + } + } + // Clear the renderer list + mRendererList.clear(); +} - RemoveTextureSet(); +void TextVisual::DoSetOffStage( Actor& actor ) +{ + RemoveRenderer( actor ); - // Resets the renderer. - mImpl->mRenderer.Reset(); - } + // Resets the renderer. + mImpl->mRenderer.Reset(); // Resets the control handle. mControl.Reset(); @@ -597,14 +611,8 @@ void TextVisual::UpdateRenderer() if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) || text.empty() ) { - // Removes the texture set. - RemoveTextureSet(); - - // Remove any renderer previously set. - if( mImpl->mRenderer ) - { - control.RemoveRenderer( mImpl->mRenderer ); - } + // Remove the texture set and any renderer previously set. + RemoveRenderer( control ); // Nothing else to do if the relayout size is zero. ResourceReady( Toolkit::Visual::ResourceStatus::READY ); @@ -620,14 +628,8 @@ void TextVisual::UpdateRenderer() { mRendererUpdateNeeded = false; - // Removes the texture set. - RemoveTextureSet(); - - // Remove any renderer previously set. - if( mImpl->mRenderer ) - { - control.RemoveRenderer( mImpl->mRenderer ); - } + // Remove the texture set and any renderer previously set. + RemoveRenderer( control ); if( ( relayoutSize.width > Math::MACHINE_EPSILON_1000 ) && ( relayoutSize.height > Math::MACHINE_EPSILON_1000 ) ) @@ -670,48 +672,196 @@ void TextVisual::UpdateRenderer() const bool styleEnabled = ( shadowEnabled || underlineEnabled || outlineEnabled || backgroundEnabled ); - TextureSet textureSet = GetTextTexture( relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled ); - mImpl->mRenderer.SetTextures( textureSet ); - Shader shader = GetTextShader( mFactoryCache, hasMultipleTextColors, containsColorGlyph, styleEnabled ); - mImpl->mRenderer.SetShader(shader); + AddRenderer( control, relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled ); - mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; + // Text rendered and ready to display + ResourceReady( Toolkit::Visual::ResourceStatus::READY ); + } + } +} - mImpl->mRenderer.RegisterProperty( "uHasMultipleTextColors", static_cast( hasMultipleTextColors ) ); +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 ); +} - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON); +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 ); + return pixelData; +} - //Register transform properties - mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); +void TextVisual::CreateTextureSet( TilingInfo& info, Renderer& renderer, Sampler& sampler, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) +{ - control.AddRenderer( mImpl->mRenderer ); + TextureSet textureSet = TextureSet::New(); + unsigned int textureSetIndex = 0u; - // Text rendered and ready to display - ResourceReady( Toolkit::Visual::ResourceStatus::READY ); - } + // Convert the buffer to pixel data to make it a texture. + if( info.textBuffer ) + { + PixelData data = ConvertToPixelData( info.textBuffer, info.width, info.height, info.offsetPosition, info.textPixelFormat ); + AddTexture( textureSet, data, sampler, textureSetIndex ); + ++textureSetIndex; } + + if( styleEnabled && info.styleBuffer ) + { + PixelData styleData = ConvertToPixelData( info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888 ); + AddTexture( textureSet, styleData, sampler, textureSetIndex ); + ++textureSetIndex; + } + + if( containsColorGlyph && !hasMultipleTextColors && info.maskBuffer ) + { + PixelData maskData = ConvertToPixelData( info.maskBuffer, info.width, info.height, info.offsetPosition, Pixel::L8 ); + AddTexture( textureSet, maskData, sampler, textureSetIndex ); + } + + renderer.SetTextures( textureSet ); + + //Register transform properties + mImpl->mTransform.RegisterUniforms( 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 ); + + // 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); + + mRendererList.push_back( renderer ); } -void TextVisual::RemoveTextureSet() + +void TextVisual::AddRenderer( Actor& actor, const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ) { - if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) + Shader shader = GetTextShader( mFactoryCache, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + mImpl->mRenderer.SetShader( shader ); + + // Get the maximum size. + const int maxTextureSize = Dali::GetMaxTextureSize(); + + // No tiling required. Use the default renderer. + if( size.height < maxTextureSize ) + { + TextureSet textureSet = GetTextTexture( size, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + + 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); + + mRendererList.push_back( mImpl->mRenderer ); + } + // If the pixel data exceeds the maximum size, tiling is required. + else { - // Removes the text's image from the texture atlas. - Vector4 atlasRect; + // Filter mode needs to be set to linear to produce better quality while scaling. + Sampler sampler = Sampler::New(); + 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; + + // 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 ); + + int verifiedWidth = data.GetWidth(); + int verifiedHeight = data.GetHeight(); + + // Set information for creating textures. + TilingInfo info( verifiedWidth, maxTextureSize, textPixelFormat ); + + // Get the buffer of text. + Dali::DevelPixelData::PixelDataBuffer textPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( data ); + info.textBuffer = textPixelData.buffer; + + 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 ); + Dali::DevelPixelData::PixelDataBuffer stylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( styleData ); + info.styleBuffer = stylePixelData.buffer; + } + + 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 ); + 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; + + // Create a textureset in the default renderer. + CreateTextureSet( info, mImpl->mRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled ); - const Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME ); - if( index != Property::INVALID_INDEX ) + verifiedHeight -= maxTextureSize; + + Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY ); + + int offsetPosition = verifiedWidth * maxTextureSize; + // Create a renderer by cutting maxTextureSize. + while( verifiedHeight > 0 ) { - const Property::Value& atlasRectValue = mImpl->mRenderer.GetProperty( index ); - atlasRectValue.Get( atlasRect ); + Renderer tilingRenderer = Renderer::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; + // New offset for tiling. + info.offSet.y += maxTextureSize; + // Create a textureset int the new tiling renderer. + CreateTextureSet( info, tilingRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled ); + + verifiedHeight -= maxTextureSize; + } + } + + mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED; - const TextureSet& textureSet = mImpl->mRenderer.GetTextures(); - mFactoryCache.GetAtlasManager()->Remove( textureSet, atlasRect ); + for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter) + { + Renderer renderer = (*iter); + if( renderer ) + { + actor.AddRenderer( renderer ); } } } + 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. @@ -731,31 +881,18 @@ TextureSet TextVisual::GetTextTexture( const Vector2& size, bool hasMultipleText // 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; - 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 ); + AddTexture( textureSet, data, sampler, textureSetIndex ); + ++textureSetIndex; 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 ); + AddTexture( textureSet, styleData, sampler, textureSetIndex ); + ++textureSetIndex; } if ( containsColorGlyph && !hasMultipleTextColors ) @@ -763,23 +900,7 @@ TextureSet TextVisual::GetTextTexture( const Vector2& size, bool hasMultipleText // 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 ); - } + AddTexture( textureSet, maskData, sampler, textureSetIndex ); } return textureSet; diff --git a/dali-toolkit/internal/visuals/text/text-visual.h b/dali-toolkit/internal/visuals/text/text-visual.h old mode 100644 new mode 100755 index 6f47e45..16da39a --- a/dali-toolkit/internal/visuals/text/text-visual.h +++ b/dali-toolkit/internal/visuals/text/text-visual.h @@ -182,6 +182,48 @@ protected: void OnSetTransform() override; private: + + struct TilingInfo + { + unsigned char* textBuffer; + unsigned char* styleBuffer; + unsigned char* maskBuffer; + int width; + int height; + Pixel::Format textPixelFormat; + int offsetPosition; + Vector2 offSet; + + TilingInfo( int width, int height, Pixel::Format textPixelFormat ) + : textBuffer( NULL ), + styleBuffer( NULL ), + maskBuffer( NULL ), + width( width ), + height( height ), + textPixelFormat( textPixelFormat ), + offsetPosition( 0 ), + offSet( 0.f, 0.f ) + { + } + + ~TilingInfo() + { + if( textBuffer ) + { + free( textBuffer ); + } + if( styleBuffer ) + { + free( styleBuffer ); + } + if( maskBuffer ) + { + free( maskBuffer ); + } + } + + }; + /** * @brief Set the individual property to the given value. * @@ -197,9 +239,50 @@ private: void UpdateRenderer(); /** - * @brief Removes the texture set from the renderer. + * @brief Removes the text's renderer. + */ + void RemoveRenderer( Actor& actor ); + + /** + * @brief Create a texture in textureSet and add it. + * @param[in] textureSet The textureSet to which the texture will be added. + * @param[in] data The PixelData to be uploaded to texture + * @param[in] sampler The sampler. + * @param[in] textureSetIndex The Index of TextureSet. + */ + void AddTexture( TextureSet& textureSet, PixelData& data, Sampler& sampler, unsigned int textureSetIndex ); + + /** + * @brief Convert the buffer to pixelData. + * @param[in] buffer The Buffer to be converted to pixelData. + * @param[in] width The width of pixel data. + * @param[in] height The height of pixel data. + * @param[in] offsetPosition The The buffer's start position. + * @param[in] textPixelFormat The PixelForma of text. + */ + PixelData ConvertToPixelData( unsigned char* buffer, int width, int height, int offsetPosition, const Pixel::Format textPixelFormat ); + + /** + * @brief Create the text's texture. + * @param[in] info This is the information you need to create a Tiling. + * @param[in] renderer The renderer to which the TextureSet will be added. + * @param[in] sampler The sampler. + * @param[in] hasMultipleTextColors Whether the text contains multiple colors. + * @param[in] containsColorGlyph Whether the text contains color glyph. + * @param[in] styleEnabled Whether the text contains any styles (e.g. shadow, underline, etc.). */ - void RemoveTextureSet(); + void CreateTextureSet( TilingInfo& info, Renderer& renderer, Sampler& sampler, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ); + + /** + * Create renderer of the text for rendering. + * @param[in] actor The actor. + * @param[in] size The texture size. + * @param[in] hasMultipleTextColors Whether the text contains multiple colors. + * @param[in] containsColorGlyph Whether the text contains color glyph. + * @param[in] styleEnabled Whether the text contains any styles (e.g. shadow, underline, etc.). + */ + void AddRenderer( Actor& actor, const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled ); + /** * Get the texture of the text for rendering. @@ -231,6 +314,8 @@ private: private: + typedef std::vector< Renderer > RendererContainer; + /** * Used as an alternative to boolean so that it is obvious whether the text contains single or multiple text colors, and emoji and styles. */ @@ -247,12 +332,14 @@ private: }; }; + private: Text::ControllerPtr mController; ///< The text's controller. Text::TypesetterPtr mTypesetter; ///< The text's typesetter. WeakHandle mControl; ///< The control where the renderer is added. Property::Index mAnimatableTextColorPropertyIndex; ///< The index of animatable text color property registered by the control. bool mRendererUpdateNeeded:1; ///< The flag to indicate whether the renderer needs to be updated. + RendererContainer mRendererList; }; } // namespace Internal -- 2.7.4