Convert more shaders in dali-toolkit and dali-scene-loader to use shader compilation...
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / text / text-visual.cpp
1 /*
2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include <dali-toolkit/internal/visuals/text/text-visual.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/animation/constraints.h>
23 #include <dali/devel-api/rendering/renderer-devel.h>
24 #include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
25 #include <dali/devel-api/adaptor-framework/image-loading.h>
26 #include <dali/devel-api/adaptor-framework/window-devel.h>
27 #include <dali/devel-api/images/pixel-data-devel.h>
28 #include <string.h>
29
30 // INTERNAL HEADER
31 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
32 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
33 #include <dali-toolkit/public-api/visuals/visual-properties.h>
34 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
35 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
36 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
37 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
38 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
39 #include <dali-toolkit/internal/text/text-font-style.h>
40 #include <dali-toolkit/internal/text/text-effects-style.h>
41 #include <dali-toolkit/internal/text/script-run.h>
42 #include <dali-toolkit/internal/text/text-enumerations-impl.h>
43 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
44 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
45
46 namespace Dali
47 {
48
49 namespace Toolkit
50 {
51
52 namespace Internal
53 {
54
55 namespace
56 {
57 const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
58
59 /**
60  * Return Property index for the given string key
61  * param[in] stringKey the string index key
62  * return the key as an index
63  */
64
65 Dali::Property::Index StringKeyToIndexKey( const std::string& stringKey )
66 {
67   Dali::Property::Index result = Property::INVALID_KEY;
68
69   if( stringKey == VISUAL_TYPE )
70   {
71     result = Toolkit::Visual::Property::TYPE;
72   }
73   else if( stringKey == TEXT_PROPERTY )
74   {
75     result = Toolkit::TextVisual::Property::TEXT;
76   }
77   else if( stringKey == FONT_FAMILY_PROPERTY )
78   {
79     result = Toolkit::TextVisual::Property::FONT_FAMILY;
80   }
81   else if( stringKey == FONT_STYLE_PROPERTY )
82   {
83     result = Toolkit::TextVisual::Property::FONT_STYLE;
84   }
85   else if( stringKey == POINT_SIZE_PROPERTY )
86   {
87     result = Toolkit::TextVisual::Property::POINT_SIZE;
88   }
89   else if( stringKey == MULTI_LINE_PROPERTY )
90   {
91     result = Toolkit::TextVisual::Property::MULTI_LINE;
92   }
93   else if( stringKey == HORIZONTAL_ALIGNMENT_PROPERTY )
94   {
95     result = Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
96   }
97   else if( stringKey == VERTICAL_ALIGNMENT_PROPERTY )
98   {
99     result = Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
100   }
101   else if( stringKey == TEXT_COLOR_PROPERTY )
102   {
103     result = Toolkit::TextVisual::Property::TEXT_COLOR;
104   }
105   else if( stringKey == ENABLE_MARKUP_PROPERTY )
106   {
107     result = Toolkit::TextVisual::Property::ENABLE_MARKUP;
108   }
109   else if( stringKey == SHADOW_PROPERTY )
110   {
111     result = Toolkit::TextVisual::Property::SHADOW;
112   }
113   else if( stringKey == UNDERLINE_PROPERTY )
114   {
115     result = Toolkit::TextVisual::Property::UNDERLINE;
116   }
117   else if( stringKey == OUTLINE_PROPERTY )
118   {
119     result = Toolkit::DevelTextVisual::Property::OUTLINE;
120   }
121   else if( stringKey == BACKGROUND_PROPERTY )
122   {
123     result = Toolkit::DevelTextVisual::Property::BACKGROUND;
124   }
125
126   return result;
127 }
128
129 void TextColorConstraint( Vector4& current, const PropertyInputContainer& inputs )
130 {
131   Vector4 color = inputs[0]->GetVector4();
132   current.r = color.r * color.a;
133   current.g = color.g * color.a;
134   current.b = color.b * color.a;
135   current.a = color.a;
136 }
137
138 void OpacityConstraint( float& current, const PropertyInputContainer& inputs )
139 {
140   // Make zero if the alpha value of text color is zero to skip rendering text
141   if( EqualsZero( inputs[0]->GetVector4().a ) )
142   {
143     current = 0.0f;
144   }
145   else
146   {
147     current = 1.0f;
148   }
149 }
150
151 } // unnamed namespace
152
153 TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
154 {
155   TextVisualPtr TextVisualPtr( new TextVisual( factoryCache ) );
156   TextVisualPtr->SetProperties( properties );
157   return TextVisualPtr;
158 }
159
160 Property::Map TextVisual::ConvertStringKeysToIndexKeys( const Property::Map& propertyMap )
161 {
162   Property::Map outMap;
163
164   for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index )
165   {
166     const KeyValuePair& keyValue = propertyMap.GetKeyValue( index );
167
168     Property::Index indexKey = keyValue.first.indexKey;
169
170     if ( keyValue.first.type == Property::Key::STRING )
171     {
172       indexKey = StringKeyToIndexKey( keyValue.first.stringKey );
173     }
174
175     outMap.Insert( indexKey, keyValue.second );
176   }
177
178   return outMap;
179 }
180
181 float TextVisual::GetHeightForWidth( float width )
182 {
183   return mController->GetHeightForWidth( width );
184 }
185
186 void TextVisual::GetNaturalSize( Vector2& naturalSize )
187 {
188   naturalSize = mController->GetNaturalSize().GetVectorXY();
189 }
190
191 void TextVisual::DoCreatePropertyMap( Property::Map& map ) const
192 {
193   Property::Value value;
194
195   map.Clear();
196   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT );
197
198   std::string text;
199   mController->GetText( text );
200   map.Insert( Toolkit::TextVisual::Property::TEXT, text );
201
202   map.Insert( Toolkit::TextVisual::Property::FONT_FAMILY, mController->GetDefaultFontFamily() );
203
204   GetFontStyleProperty( mController, value, Text::FontStyle::DEFAULT );
205   map.Insert( Toolkit::TextVisual::Property::FONT_STYLE, value );
206
207   map.Insert( Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ) );
208
209   map.Insert( Toolkit::TextVisual::Property::MULTI_LINE, mController->IsMultiLineEnabled() );
210
211   map.Insert( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, mController->GetHorizontalAlignment() );
212
213   map.Insert( Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, mController->GetVerticalAlignment() );
214
215   map.Insert( Toolkit::TextVisual::Property::TEXT_COLOR, mController->GetDefaultColor() );
216
217   map.Insert( Toolkit::TextVisual::Property::ENABLE_MARKUP, mController->IsMarkupProcessorEnabled() );
218
219   GetShadowProperties( mController, value, Text::EffectStyle::DEFAULT );
220   map.Insert( Toolkit::TextVisual::Property::SHADOW, value );
221
222   GetUnderlineProperties( mController, value, Text::EffectStyle::DEFAULT );
223   map.Insert( Toolkit::TextVisual::Property::UNDERLINE, value );
224
225   GetOutlineProperties( mController, value, Text::EffectStyle::DEFAULT );
226   map.Insert( Toolkit::DevelTextVisual::Property::OUTLINE, value );
227
228   GetBackgroundProperties( mController, value, Text::EffectStyle::DEFAULT );
229   map.Insert( Toolkit::DevelTextVisual::Property::BACKGROUND, value );
230 }
231
232 void TextVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
233 {
234   map.Clear();
235   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT );
236   std::string text;
237   mController->GetText( text );
238   map.Insert( Toolkit::TextVisual::Property::TEXT, text );
239 }
240
241
242 TextVisual::TextVisual( VisualFactoryCache& factoryCache )
243 : Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO, Toolkit::Visual::TEXT ),
244   mController( Text::Controller::New() ),
245   mTypesetter( Text::Typesetter::New( mController->GetTextModel() ) ),
246   mAnimatableTextColorPropertyIndex( Property::INVALID_INDEX ),
247   mRendererUpdateNeeded( false )
248 {
249 }
250
251 TextVisual::~TextVisual()
252 {
253 }
254
255 void TextVisual::DoSetProperties( const Property::Map& propertyMap )
256 {
257   for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index )
258   {
259     const KeyValuePair& keyValue = propertyMap.GetKeyValue( index );
260
261     Property::Index indexKey = keyValue.first.indexKey;
262
263     if( keyValue.first.type == Property::Key::STRING )
264     {
265       indexKey = StringKeyToIndexKey( keyValue.first.stringKey );
266     }
267
268     DoSetProperty( indexKey, keyValue.second );
269   }
270
271   // Elide the text if it exceeds the boundaries.
272   mController->SetTextElideEnabled( true );
273
274   // Retrieve the layout engine to set the cursor's width.
275   Text::Layout::Engine& engine = mController->GetLayoutEngine();
276
277   // Sets 0 as cursor's width.
278   engine.SetCursorWidth( 0u ); // Do not layout space for the cursor.
279 }
280
281 void TextVisual::DoSetOnScene( Actor& actor )
282 {
283   mControl = actor;
284
285   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
286   Shader shader = GetTextShader(mFactoryCache, TextType::SINGLE_COLOR_TEXT, TextType::NO_EMOJI, TextType::NO_STYLES);
287
288   mImpl->mRenderer = Renderer::New( geometry, shader );
289   mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT );
290
291   // Enable the pre-multiplied alpha to improve the text quality
292   EnablePreMultipliedAlpha(true);
293
294   const Vector4& defaultColor = mController->GetTextModel()->GetDefaultColor();
295   Dali::Property::Index shaderTextColorIndex = mImpl->mRenderer.RegisterProperty( "uTextColorAnimatable", defaultColor );
296
297   if ( mAnimatableTextColorPropertyIndex != Property::INVALID_INDEX )
298   {
299     // Create constraint for the animatable text's color Property with uTextColorAnimatable in the renderer.
300     if( shaderTextColorIndex != Property::INVALID_INDEX )
301     {
302       Constraint colorConstraint = Constraint::New<Vector4>( mImpl->mRenderer, shaderTextColorIndex, TextColorConstraint );
303       colorConstraint.AddSource( Source( actor, mAnimatableTextColorPropertyIndex ) );
304       colorConstraint.Apply();
305
306       // Make zero if the alpha value of text color is zero to skip rendering text
307       Constraint opacityConstraint = Constraint::New< float >( mImpl->mRenderer, Dali::DevelRenderer::Property::OPACITY, OpacityConstraint );
308       opacityConstraint.AddSource( Source( actor, mAnimatableTextColorPropertyIndex ) );
309       opacityConstraint.Apply();
310     }
311   }
312
313   // Renderer needs textures and to be added to control
314   mRendererUpdateNeeded = true;
315
316   mRendererList.push_back( mImpl->mRenderer );
317
318   UpdateRenderer();
319 }
320
321 void TextVisual::RemoveRenderer( Actor& actor )
322 {
323   for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter)
324   {
325     Renderer renderer = (*iter);
326     if( renderer )
327     {
328       // Removes the renderer from the actor.
329       actor.RemoveRenderer( renderer );
330     }
331   }
332   // Clear the renderer list
333   mRendererList.clear();
334 }
335
336 void TextVisual::DoSetOffScene( Actor& actor )
337 {
338   RemoveRenderer( actor );
339
340   // Resets the renderer.
341   mImpl->mRenderer.Reset();
342
343   // Resets the control handle.
344   mControl.Reset();
345 }
346
347 void TextVisual::OnSetTransform()
348 {
349   UpdateRenderer();
350 }
351
352 void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
353 {
354   switch( index )
355   {
356     case Toolkit::TextVisual::Property::ENABLE_MARKUP:
357     {
358       const bool enableMarkup = propertyValue.Get<bool>();
359       mController->SetMarkupProcessorEnabled( enableMarkup );
360       break;
361     }
362     case Toolkit::TextVisual::Property::TEXT:
363     {
364       mController->SetText( propertyValue.Get<std::string>() );
365       break;
366     }
367     case Toolkit::TextVisual::Property::FONT_FAMILY:
368     {
369       SetFontFamilyProperty( mController, propertyValue );
370       break;
371     }
372     case Toolkit::TextVisual::Property::FONT_STYLE:
373     {
374       SetFontStyleProperty( mController, propertyValue, Text::FontStyle::DEFAULT );
375       break;
376     }
377     case Toolkit::TextVisual::Property::POINT_SIZE:
378     {
379       const float pointSize = propertyValue.Get<float>();
380       if( !Equals( mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
381       {
382         mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
383       }
384       break;
385     }
386     case Toolkit::TextVisual::Property::MULTI_LINE:
387     {
388       mController->SetMultiLineEnabled( propertyValue.Get<bool>() );
389       break;
390     }
391     case Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT:
392     {
393       if( mController )
394       {
395         Text::HorizontalAlignment::Type alignment( static_cast< Text::HorizontalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set
396         if( Toolkit::Text::GetHorizontalAlignmentEnumeration( propertyValue, alignment ) )
397         {
398           mController->SetHorizontalAlignment( alignment );
399         }
400       }
401       break;
402     }
403     case Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT:
404     {
405       if( mController )
406       {
407         Toolkit::Text::VerticalAlignment::Type alignment( static_cast< Text::VerticalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set
408         if( Toolkit::Text::GetVerticalAlignmentEnumeration( propertyValue, alignment) )
409         {
410           mController->SetVerticalAlignment( alignment );
411         }
412       }
413       break;
414     }
415     case Toolkit::TextVisual::Property::TEXT_COLOR:
416     {
417       const Vector4& textColor = propertyValue.Get< Vector4 >();
418       if( mController->GetDefaultColor() != textColor )
419       {
420         mController->SetDefaultColor( textColor );
421       }
422       break;
423     }
424     case Toolkit::TextVisual::Property::SHADOW:
425     {
426       SetShadowProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
427       break;
428     }
429     case Toolkit::TextVisual::Property::UNDERLINE:
430     {
431       SetUnderlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
432       break;
433     }
434     case Toolkit::DevelTextVisual::Property::OUTLINE:
435     {
436       SetOutlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
437       break;
438     }
439     case Toolkit::DevelTextVisual::Property::BACKGROUND:
440     {
441       SetBackgroundProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
442       break;
443     }
444   }
445 }
446
447 void TextVisual::UpdateRenderer()
448 {
449   Actor control = mControl.GetHandle();
450   if( !control )
451   {
452     // Nothing to do.
453     return;
454   }
455
456   // Calculates the size to be used to relayout.
457   Vector2 relayoutSize;
458
459   const bool isWidthRelative = fabsf( mImpl->mTransform.mOffsetSizeMode.z ) < Math::MACHINE_EPSILON_1000;
460   const bool isHeightRelative = fabsf( mImpl->mTransform.mOffsetSizeMode.w ) < Math::MACHINE_EPSILON_1000;
461
462   // Round the size and offset to avoid pixel alignement issues.
463   relayoutSize.width = floorf( 0.5f + ( isWidthRelative ? mImpl->mControlSize.width * mImpl->mTransform.mSize.x : mImpl->mTransform.mSize.width ) );
464   relayoutSize.height = floorf( 0.5f + ( isHeightRelative ? mImpl->mControlSize.height * mImpl->mTransform.mSize.y : mImpl->mTransform.mSize.height ) );
465
466   std::string text;
467   mController->GetText( text );
468
469   if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) || text.empty() )
470   {
471     // Remove the texture set and any renderer previously set.
472     RemoveRenderer( control );
473
474     // Nothing else to do if the relayout size is zero.
475     ResourceReady( Toolkit::Visual::ResourceStatus::READY );
476     return;
477   }
478
479
480   Dali::LayoutDirection::Type layoutDirection;
481   if( mController->IsMatchSystemLanguageDirection() )
482   {
483     layoutDirection = static_cast<Dali::LayoutDirection::Type>( DevelWindow::Get( control ).GetRootLayer().GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
484   }
485   else
486   {
487     layoutDirection = static_cast<Dali::LayoutDirection::Type>( control.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
488   }
489
490   const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize, layoutDirection );
491
492   if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType )
493    || mRendererUpdateNeeded )
494   {
495     mRendererUpdateNeeded = false;
496
497     // Remove the texture set and any renderer previously set.
498     RemoveRenderer( control );
499
500     if( ( relayoutSize.width > Math::MACHINE_EPSILON_1000 ) &&
501         ( relayoutSize.height > Math::MACHINE_EPSILON_1000 ) )
502     {
503       // Check whether it is a markup text with multiple text colors
504       const Vector4* const colorsBuffer = mController->GetTextModel()->GetColors();
505       bool hasMultipleTextColors = ( NULL != colorsBuffer );
506
507       // Check whether the text contains any color glyph
508       bool containsColorGlyph = false;
509
510       TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
511       const Text::GlyphInfo* const glyphsBuffer = mController->GetTextModel()->GetGlyphs();
512       const Text::Length numberOfGlyphs = mController->GetTextModel()->GetNumberOfGlyphs();
513       for ( Text::Length glyphIndex = 0; glyphIndex < numberOfGlyphs; glyphIndex++ )
514       {
515         // Retrieve the glyph's info.
516         const Text::GlyphInfo* const glyphInfo = glyphsBuffer + glyphIndex;
517
518         // Whether the current glyph is a color one.
519         if( fontClient.IsColorGlyph( glyphInfo->fontId, glyphInfo->index ) )
520         {
521           containsColorGlyph = true;
522           break;
523         }
524       }
525
526       // Check whether the text contains any style colors (e.g. underline color, shadow color, etc.)
527
528       bool shadowEnabled = false;
529       const Vector2& shadowOffset = mController->GetTextModel()->GetShadowOffset();
530       if ( fabsf( shadowOffset.x ) > Math::MACHINE_EPSILON_1 || fabsf( shadowOffset.y ) > Math::MACHINE_EPSILON_1 )
531       {
532         shadowEnabled = true;
533       }
534
535       const bool underlineEnabled = mController->GetTextModel()->IsUnderlineEnabled();
536       const bool outlineEnabled = ( mController->GetTextModel()->GetOutlineWidth() > Math::MACHINE_EPSILON_1 );
537       const bool backgroundEnabled = mController->GetTextModel()->IsBackgroundEnabled();;
538
539       const bool styleEnabled = ( shadowEnabled || underlineEnabled || outlineEnabled || backgroundEnabled );
540
541
542       AddRenderer( control, relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled );
543
544       // Text rendered and ready to display
545       ResourceReady( Toolkit::Visual::ResourceStatus::READY );
546     }
547   }
548 }
549
550 void TextVisual::AddTexture( TextureSet& textureSet, PixelData& data, Sampler& sampler, unsigned int textureSetIndex )
551 {
552   Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D,
553                                   data.GetPixelFormat(),
554                                   data.GetWidth(),
555                                   data.GetHeight() );
556   texture.Upload( data );
557
558   textureSet.SetTexture( textureSetIndex, texture );
559   textureSet.SetSampler( textureSetIndex, sampler );
560 }
561
562 PixelData TextVisual::ConvertToPixelData( unsigned char* buffer, int width, int height, int offsetPosition, const Pixel::Format textPixelFormat )
563 {
564   int bpp = Pixel::GetBytesPerPixel( textPixelFormat );
565   unsigned int bufferSize = width * height * bpp;
566   unsigned char* dstBuffer = static_cast<unsigned char*>( malloc ( bufferSize ) );
567   memcpy( dstBuffer, buffer + offsetPosition * bpp, bufferSize );
568   PixelData pixelData = Dali::PixelData::New( dstBuffer,
569                                               bufferSize,
570                                               width,
571                                               height,
572                                               textPixelFormat,
573                                               Dali::PixelData::FREE );
574   return pixelData;
575 }
576
577 void TextVisual::CreateTextureSet( TilingInfo& info, Renderer& renderer, Sampler& sampler, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
578 {
579
580   TextureSet textureSet = TextureSet::New();
581   unsigned int textureSetIndex = 0u;
582
583   // Convert the buffer to pixel data to make it a texture.
584   if( info.textBuffer )
585   {
586     PixelData data = ConvertToPixelData( info.textBuffer, info.width, info.height, info.offsetPosition, info.textPixelFormat );
587     AddTexture( textureSet, data, sampler, textureSetIndex );
588     ++textureSetIndex;
589   }
590
591   if( styleEnabled && info.styleBuffer )
592   {
593     PixelData styleData = ConvertToPixelData( info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888 );
594     AddTexture( textureSet, styleData, sampler, textureSetIndex );
595     ++textureSetIndex;
596   }
597
598   if( containsColorGlyph && !hasMultipleTextColors && info.maskBuffer )
599   {
600     PixelData maskData = ConvertToPixelData( info.maskBuffer, info.width, info.height, info.offsetPosition, Pixel::L8 );
601     AddTexture( textureSet, maskData, sampler, textureSetIndex );
602   }
603
604   renderer.SetTextures( textureSet );
605
606   //Register transform properties
607   mImpl->mTransform.RegisterUniforms( renderer, Direction::LEFT_TO_RIGHT );
608
609   // Enable the pre-multiplied alpha to improve the text quality
610   renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true );
611   renderer.RegisterProperty( PREMULTIPLIED_ALPHA, 1.0f );
612
613   // Set size and offset for the tiling.
614   renderer.RegisterProperty( SIZE, Vector2( info.width, info.height ) );
615   renderer.RegisterProperty( OFFSET, Vector2( info.offSet.x, info.offSet.y ) );
616   renderer.RegisterProperty( "uHasMultipleTextColors", static_cast<float>( hasMultipleTextColors ) );
617   renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON);
618
619   mRendererList.push_back( renderer );
620 }
621
622
623 void TextVisual::AddRenderer( Actor& actor, const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
624 {
625   Shader shader = GetTextShader( mFactoryCache, hasMultipleTextColors, containsColorGlyph, styleEnabled );
626   mImpl->mRenderer.SetShader( shader );
627
628   // Get the maximum size.
629   const int maxTextureSize = Dali::GetMaxTextureSize();
630
631   // No tiling required. Use the default renderer.
632   if( size.height < maxTextureSize )
633   {
634     TextureSet textureSet = GetTextTexture( size, hasMultipleTextColors, containsColorGlyph, styleEnabled );
635
636     mImpl->mRenderer.SetTextures( textureSet );
637     //Register transform properties
638     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
639     mImpl->mRenderer.RegisterProperty( "uHasMultipleTextColors", static_cast<float>( hasMultipleTextColors ) );
640     mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON);
641
642     mRendererList.push_back( mImpl->mRenderer );
643   }
644   // If the pixel data exceeds the maximum size, tiling is required.
645   else
646   {
647     // Filter mode needs to be set to linear to produce better quality while scaling.
648     Sampler sampler = Sampler::New();
649     sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
650
651     // Create RGBA texture if the text contains emojis or multiple text colors, otherwise L8 texture
652     Pixel::Format textPixelFormat = ( containsColorGlyph || hasMultipleTextColors ) ? Pixel::RGBA8888 : Pixel::L8;
653
654     // Check the text direction
655     Toolkit::DevelText::TextDirection::Type textDirection = mController->GetTextDirection();
656
657     // Create a texture for the text without any styles
658     PixelData data = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_STYLES, false, textPixelFormat );
659
660     int verifiedWidth = data.GetWidth();
661     int verifiedHeight = data.GetHeight();
662
663     // Set information for creating textures.
664     TilingInfo info( verifiedWidth, maxTextureSize, textPixelFormat );
665
666     // Get the buffer of text.
667     Dali::DevelPixelData::PixelDataBuffer textPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( data );
668     info.textBuffer = textPixelData.buffer;
669
670     if( styleEnabled )
671     {
672       // Create RGBA texture for all the text styles (without the text itself)
673       PixelData styleData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888 );
674       Dali::DevelPixelData::PixelDataBuffer stylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( styleData );
675       info.styleBuffer = stylePixelData.buffer;
676     }
677
678     if ( containsColorGlyph && !hasMultipleTextColors )
679     {
680       // Create a L8 texture as a mask to avoid color glyphs (e.g. emojis) to be affected by text color animation
681       PixelData maskData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8 );
682       Dali::DevelPixelData::PixelDataBuffer maskPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( maskData );
683       info.maskBuffer = maskPixelData.buffer;
684     }
685
686     // Get the current offset for recalculate the offset when tiling.
687     Property::Map retMap;
688     mImpl->mTransform.GetPropertyMap( retMap );
689     Property::Value* offsetValue = retMap.Find( Dali::Toolkit::Visual::Transform::Property::OFFSET );
690     if( offsetValue )
691     {
692       offsetValue->Get( info.offSet );
693     }
694
695     // Create a textureset in the default renderer.
696     CreateTextureSet( info, mImpl->mRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled );
697
698     verifiedHeight -= maxTextureSize;
699
700     Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
701
702     int offsetPosition = verifiedWidth * maxTextureSize;
703     // Create a renderer by cutting maxTextureSize.
704     while( verifiedHeight > 0 )
705     {
706       Renderer tilingRenderer = Renderer::New( geometry, shader );
707       tilingRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT );
708       // New offset position of buffer for tiling.
709       info.offsetPosition += offsetPosition;
710       // New height for tiling.
711       info.height = ( verifiedHeight - maxTextureSize ) > 0 ? maxTextureSize : verifiedHeight;
712       // New offset for tiling.
713       info.offSet.y += maxTextureSize;
714       // Create a textureset int the new tiling renderer.
715       CreateTextureSet( info, tilingRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled );
716
717       verifiedHeight -= maxTextureSize;
718     }
719   }
720
721   mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
722
723   for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter)
724   {
725     Renderer renderer = (*iter);
726     if( renderer )
727     {
728       actor.AddRenderer( renderer );
729     }
730   }
731 }
732
733
734 TextureSet TextVisual::GetTextTexture( const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
735 {
736   // Filter mode needs to be set to linear to produce better quality while scaling.
737   Sampler sampler = Sampler::New();
738   sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
739
740   TextureSet textureSet = TextureSet::New();
741
742   // Create RGBA texture if the text contains emojis or multiple text colors, otherwise L8 texture
743   Pixel::Format textPixelFormat = ( containsColorGlyph || hasMultipleTextColors ) ? Pixel::RGBA8888 : Pixel::L8;
744
745   // Check the text direction
746   Toolkit::DevelText::TextDirection::Type textDirection = mController->GetTextDirection();
747
748   // Create a texture for the text without any styles
749   PixelData data = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_STYLES, false, textPixelFormat );
750
751   // It may happen the image atlas can't handle a pixel data it exceeds the maximum size.
752   // In that case, create a texture. TODO: should tile the text.
753   unsigned int textureSetIndex = 0u;
754
755   AddTexture( textureSet, data, sampler, textureSetIndex );
756   ++textureSetIndex;
757
758   if ( styleEnabled )
759   {
760     // Create RGBA texture for all the text styles (without the text itself)
761     PixelData styleData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888 );
762
763     AddTexture( textureSet, styleData, sampler, textureSetIndex );
764     ++textureSetIndex;
765   }
766
767   if ( containsColorGlyph && !hasMultipleTextColors )
768   {
769     // Create a L8 texture as a mask to avoid color glyphs (e.g. emojis) to be affected by text color animation
770     PixelData maskData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8 );
771
772     AddTexture( textureSet, maskData, sampler, textureSetIndex );
773   }
774
775   return textureSet;
776 }
777
778 Shader TextVisual::GetTextShader( VisualFactoryCache& factoryCache, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
779 {
780   Shader shader;
781
782   if( hasMultipleTextColors && !styleEnabled )
783   {
784     // We don't animate text color if the text contains multiple colors
785     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT );
786     if( !shader )
787     {
788       shader = Shader::New( SHADER_TEXT_VISUAL_SHADER_VERT, SHADER_TEXT_VISUAL_MULTI_COLOR_TEXT_SHADER_FRAG );
789       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
790       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT, shader );
791     }
792   }
793   else if( hasMultipleTextColors && styleEnabled )
794   {
795     // We don't animate text color if the text contains multiple colors
796     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE );
797     if( !shader )
798     {
799       shader = Shader::New( SHADER_TEXT_VISUAL_SHADER_VERT, SHADER_TEXT_VISUAL_MULTI_COLOR_TEXT_WITH_STYLE_SHADER_FRAG );
800       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
801       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE, shader );
802     }
803   }
804   else if( !hasMultipleTextColors && !containsColorGlyph && !styleEnabled )
805   {
806     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT );
807     if( !shader )
808     {
809       shader = Shader::New( SHADER_TEXT_VISUAL_SHADER_VERT, SHADER_TEXT_VISUAL_SINGLE_COLOR_TEXT_SHADER_FRAG );
810       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
811       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT, shader );
812     }
813   }
814   else if( !hasMultipleTextColors && !containsColorGlyph && styleEnabled )
815   {
816     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE );
817     if( !shader )
818     {
819       shader = Shader::New( SHADER_TEXT_VISUAL_SHADER_VERT, SHADER_TEXT_VISUAL_SINGLE_COLOR_TEXT_WITH_STYLE_SHADER_FRAG );
820       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
821       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE, shader );
822     }
823   }
824   else if( !hasMultipleTextColors && containsColorGlyph && !styleEnabled )
825   {
826     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI );
827     if( !shader )
828     {
829       shader = Shader::New( SHADER_TEXT_VISUAL_SHADER_VERT, SHADER_TEXT_VISUAL_SINGLE_COLOR_TEXT_WITH_EMOJI_SHADER_FRAG );
830       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
831       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI, shader );
832     }
833   }
834   else // if( !hasMultipleTextColors && containsColorGlyph && styleEnabled )
835   {
836     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI );
837     if( !shader )
838     {
839       shader = Shader::New( SHADER_TEXT_VISUAL_SHADER_VERT, SHADER_TEXT_VISUAL_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI_SHADER_FRAG );
840       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
841       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI, shader );
842     }
843   }
844
845   return shader;
846 }
847
848 } // namespace Internal
849
850 } // namespace Toolkit
851
852 } // namespace Dali