2 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali-toolkit/internal/text/rendering/text-typesetter.h>
23 #include <dali/devel-api/text-abstraction/font-client.h>
24 #include <dali/public-api/common/constants.h>
27 #include <dali-toolkit/internal/text/rendering/view-model.h>
28 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
43 * @brief Data struct used to set the buffer of the glyph's bitmap into the final bitmap's buffer.
47 Devel::PixelBuffer bitmapBuffer; ///< The buffer of the whole bitmap. The format is RGBA8888.
48 Vector2* position; ///< The position of the glyph.
49 TextAbstraction::FontClient::GlyphBufferData glyphBitmap; ///< The glyph's bitmap.
50 unsigned int width; ///< The bitmap's width.
51 unsigned int height; ///< The bitmap's height.
52 int horizontalOffset; ///< The horizontal offset to be added to the 'x' glyph's position.
53 int verticalOffset; ///< The vertical offset to be added to the 'y' glyph's position.
57 * @brief Sets the glyph's buffer into the bitmap's buffer.
59 * @param[in] data Struct which contains the glyph's data and the bitmap's data.
60 * @param[in] position The position of the glyph.
61 * @param[in] color The color of the glyph.
62 * @param[in] style The style of the text.
63 * @param[in] pixelFormat The format of the pixel in the image that the text is rendered as (i.e. either Pixel::BGRA8888 or Pixel::L8).
65 void TypesetGlyph( GlyphData& data,
66 const Vector2* const position,
67 const Vector4* const color,
68 Typesetter::Style style,
69 Pixel::Format pixelFormat )
71 if( ( 0u == data.glyphBitmap.width ) || ( 0u == data.glyphBitmap.height ) )
73 // Nothing to do if the width or height of the buffer is zero.
77 const int widthMinusOne = static_cast<int>( data.width - 1u );
78 const int heightMinusOne = static_cast<int>( data.height - 1u );
80 if ( Pixel::RGBA8888 == pixelFormat )
82 // Whether the given glyph is a color one.
83 const bool isColorGlyph = Pixel::BGRA8888 == data.glyphBitmap.format;
85 // Pointer to the color glyph if there is one.
86 const uint32_t* const colorGlyphBuffer = isColorGlyph ? reinterpret_cast<uint32_t*>( data.glyphBitmap.buffer ) : NULL;
88 // Pack the given color into a 32bit buffer. The alpha channel will be updated later for each pixel.
89 // The format is RGBA8888.
90 uint32_t packedColor = 0u;
91 uint8_t* packedColorBuffer = reinterpret_cast<uint8_t*>( &packedColor );
92 *( packedColorBuffer + 2 ) = static_cast<uint8_t>( color->b * 255.f );
93 *( packedColorBuffer + 1 ) = static_cast<uint8_t>( color->g * 255.f );
94 *packedColorBuffer = static_cast<uint8_t>( color->r * 255.f );
96 // Initial vertical offset.
97 const int yOffset = data.verticalOffset + position->y;
99 // Traverse the pixels of the glyph line per line.
100 for( int lineIndex = 0, glyphHeight = static_cast<int>( data.glyphBitmap.height ); lineIndex < glyphHeight; ++lineIndex )
102 const int yOffsetIndex = yOffset + lineIndex;
103 if( ( 0 > yOffsetIndex ) || ( yOffsetIndex > heightMinusOne ) )
105 // Do not write out of bounds.
109 const int verticalOffset = yOffsetIndex * data.width;
110 const int xOffset = data.horizontalOffset + position->x;
111 const int glyphBufferOffset = lineIndex * static_cast<int>( data.glyphBitmap.width );
112 for( int index = 0, glyphWidth = static_cast<int>( data.glyphBitmap.width ); index < glyphWidth; ++index )
114 const int xOffsetIndex = xOffset + index;
115 if( ( 0 > xOffsetIndex ) || ( xOffsetIndex > widthMinusOne ) )
117 // Don't write out of bounds.
121 uint32_t* bitmapBuffer = reinterpret_cast< uint32_t* >( data.bitmapBuffer.GetBuffer() );
125 // Retrieves the color from the color glyph. The format is BGRA8888.
126 uint32_t packedColorGlyph = *( colorGlyphBuffer + glyphBufferOffset + index );
127 uint8_t* packedColorGlyphBuffer = reinterpret_cast<uint8_t*>( &packedColorGlyph );
129 if( Typesetter::STYLE_SHADOW == style )
131 // The shadow of color glyph needs to have the shadow color.
132 *( packedColorGlyphBuffer + 2 ) = static_cast<uint8_t>( color->b * 255.f );
133 *( packedColorGlyphBuffer + 1 ) = static_cast<uint8_t>( color->g * 255.f );
134 *packedColorGlyphBuffer = static_cast<uint8_t>( color->r * 255.f );
138 std::swap( *packedColorGlyphBuffer, *( packedColorGlyphBuffer + 2u ) ); // Swap B and R.
141 // Update the alpha channel.
142 if( Typesetter::STYLE_MASK == style || Typesetter::STYLE_OUTLINE == style ) // Outline not shown for color glyph
144 // Create an alpha mask for color glyph.
145 *( packedColorGlyphBuffer + 3u ) = 0u;
149 *( packedColorGlyphBuffer + 3u ) = static_cast<uint8_t>( color->a * static_cast<float>( *( packedColorGlyphBuffer + 3u ) ) );
152 // Set the color into the final pixel buffer.
153 *( bitmapBuffer + verticalOffset + xOffsetIndex ) = packedColorGlyph;
157 // Update the alpha channel.
158 const uint8_t alpha = *( data.glyphBitmap.buffer + glyphBufferOffset + index );
160 // Copy non-transparent pixels only
163 // Check alpha of overlapped pixels
164 uint32_t& currentColor = *( bitmapBuffer + verticalOffset + xOffsetIndex );
165 uint8_t* packedCurrentColorBuffer = reinterpret_cast<uint8_t*>( ¤tColor );
167 uint8_t currentAlpha = *( packedCurrentColorBuffer + 3u );
168 uint8_t newAlpha = static_cast<uint8_t>( color->a * static_cast<float>( alpha ) );
170 // For any pixel overlapped with the pixel in previous glyphs, make sure we don't
171 // overwrite a previous bigger alpha with a smaller alpha (in order to avoid
172 // semi-transparent gaps between joint glyphs with overlapped pixels, which could
173 // happen, for example, in the RTL text when we copy glyphs from right to left).
174 *( packedColorBuffer + 3u ) = std::max( currentAlpha, newAlpha );
176 // Set the color into the final pixel buffer.
177 currentColor = packedColor;
185 // Whether the given glyph is a color one.
186 const bool isColorGlyph = Pixel::BGRA8888 == data.glyphBitmap.format;
188 // Initial vertical offset.
189 const int yOffset = data.verticalOffset + position->y;
191 // Traverse the pixels of the glyph line per line.
192 for( int lineIndex = 0, glyphHeight = static_cast<int>( data.glyphBitmap.height ); lineIndex < glyphHeight; ++lineIndex )
194 const int yOffsetIndex = yOffset + lineIndex;
195 if( ( 0 > yOffsetIndex ) || ( yOffsetIndex > heightMinusOne ) )
197 // Do not write out of bounds.
201 const int verticalOffset = yOffsetIndex * data.width;
202 const int xOffset = data.horizontalOffset + position->x;
203 const int glyphBufferOffset = lineIndex * static_cast<int>( data.glyphBitmap.width );
204 for( int index = 0, glyphWidth = static_cast<int>( data.glyphBitmap.width ); index < glyphWidth; ++index )
206 const int xOffsetIndex = xOffset + index;
207 if( ( 0 > xOffsetIndex ) || ( xOffsetIndex > widthMinusOne ) )
209 // Don't write out of bounds.
213 uint8_t* bitmapBuffer = reinterpret_cast< uint8_t* >( data.bitmapBuffer.GetBuffer() );
217 // Update the alpha channel.
218 const uint8_t alpha = *( data.glyphBitmap.buffer + glyphBufferOffset + index );
220 // Copy non-transparent pixels only
223 // Check alpha of overlapped pixels
224 uint8_t& currentAlpha = *( bitmapBuffer + verticalOffset + xOffsetIndex );
225 uint8_t newAlpha = static_cast<uint8_t>( color->a * static_cast<float>( alpha ) );
227 // For any pixel overlapped with the pixel in previous glyphs, make sure we don't
228 // overwrite a previous bigger alpha with a smaller alpha (in order to avoid
229 // semi-transparent gaps between joint glyphs with overlapped pixels, which could
230 // happen, for example, in the RTL text when we copy glyphs from right to left).
231 *( bitmapBuffer + verticalOffset + xOffsetIndex ) = std::max( currentAlpha, newAlpha );
239 bool IsGlyphUnderlined( GlyphIndex index,
240 const Vector<GlyphRun>& underlineRuns )
242 for( Vector<GlyphRun>::ConstIterator it = underlineRuns.Begin(),
243 endIt = underlineRuns.End();
247 const GlyphRun& run = *it;
249 if( ( run.glyphIndex <= index ) && ( index < run.glyphIndex + run.numberOfGlyphs ) )
260 TypesetterPtr Typesetter::New( const ModelInterface* const model )
262 return TypesetterPtr( new Typesetter( model ) );
265 ViewModel* Typesetter::GetViewModel()
270 PixelData Typesetter::Render( const Vector2& size, Toolkit::DevelText::TextDirection::Type textDirection, RenderBehaviour behaviour, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat )
272 // @todo. This initial implementation for a TextLabel has only one visible page.
274 // Elides the text if needed.
275 mModel->ElideGlyphs();
277 // Retrieves the layout size.
278 const Size& layoutSize = mModel->GetLayoutSize();
280 const float outlineWidth = mModel->GetOutlineWidth();
282 // Set the offset for the horizontal alignment according to the text direction and outline width.
285 switch( mModel->GetHorizontalAlignment() )
287 case HorizontalAlignment::BEGIN:
292 case HorizontalAlignment::CENTER:
294 penX += ( textDirection == Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT ) ? -outlineWidth : outlineWidth;
297 case HorizontalAlignment::END:
299 penX += ( textDirection == Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT ) ? -outlineWidth * 2.0f : outlineWidth * 2.0f;
304 // Set the offset for the vertical alignment.
307 switch( mModel->GetVerticalAlignment() )
309 case VerticalAlignment::TOP:
314 case VerticalAlignment::CENTER:
316 penY = static_cast<int>( 0.5f * ( size.height - layoutSize.height ) );
319 case VerticalAlignment::BOTTOM:
321 penY = static_cast<int>( size.height - layoutSize.height );
326 // Calculate vertical line alignment
327 switch( mModel->GetVerticalLineAlignment() )
329 case DevelText::VerticalLineAlignment::TOP:
333 case DevelText::VerticalLineAlignment::MIDDLE:
335 const auto& line = *mModel->GetLines();
336 penY -= line.descender;
337 penY += static_cast<int>(line.lineSpacing*0.5f + line.descender);
340 case DevelText::VerticalLineAlignment::BOTTOM:
342 const auto& line = *mModel->GetLines();
343 const auto lineHeight = line.ascender + (-line.descender) + line.lineSpacing;
344 penY += static_cast<int>(lineHeight - (line.ascender - line.descender));
349 // Generate the image buffers of the text for each different style first,
350 // then combine all of them together as one final image buffer. We try to
351 // do all of these in CPU only, so that once the final texture is generated,
352 // no calculation is needed in GPU during each frame.
354 const unsigned int bufferWidth = static_cast<unsigned int>( size.width );
355 const unsigned int bufferHeight = static_cast<unsigned int>( size.height );
357 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
358 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
360 Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
362 Devel::PixelBuffer imageBuffer;
364 if( RENDER_MASK == behaviour )
366 // Generate the image buffer as an alpha mask for color glyphs.
367 imageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_MASK, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1 );
369 else if( RENDER_NO_TEXT == behaviour )
371 // Generate an empty image buffer so that it can been combined with the image buffers for styles
372 imageBuffer = Devel::PixelBuffer::New( bufferWidth, bufferHeight, Pixel::RGBA8888 );
373 memset( imageBuffer.GetBuffer(), 0u, bufferSizeChar );
377 // Generate the image buffer for the text with no style.
378 imageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_NONE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs -1 );
381 if ( ( RENDER_NO_STYLES != behaviour ) && ( RENDER_MASK != behaviour ) )
384 // Generate the outline if enabled
385 const float outlineWidth = mModel->GetOutlineWidth();
386 if ( outlineWidth > Math::MACHINE_EPSILON_1 )
388 // Create the image buffer for outline
389 Devel::PixelBuffer outlineImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_OUTLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs -1 );
391 // Combine the two buffers
392 imageBuffer = CombineImageBuffer( imageBuffer, outlineImageBuffer, bufferWidth, bufferHeight );
395 // @todo. Support shadow and underline for partial text later on.
397 // Generate the shadow if enabled
398 const Vector2& shadowOffset = mModel->GetShadowOffset();
399 if ( fabsf( shadowOffset.x ) > Math::MACHINE_EPSILON_1 || fabsf( shadowOffset.y ) > Math::MACHINE_EPSILON_1 )
401 // Create the image buffer for shadow
402 Devel::PixelBuffer shadowImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_SHADOW, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1 );
404 // Check whether it will be a soft shadow
405 const float& blurRadius = mModel->GetShadowBlurRadius();
407 if ( blurRadius > Math::MACHINE_EPSILON_1 )
409 shadowImageBuffer.ApplyGaussianBlur( blurRadius );
412 // Combine the two buffers
413 imageBuffer = CombineImageBuffer( imageBuffer, shadowImageBuffer, bufferWidth, bufferHeight );
416 // Generate the underline if enabled
417 const bool underlineEnabled = mModel->IsUnderlineEnabled();
418 if ( underlineEnabled )
420 // Create the image buffer for underline
421 Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1 );
423 // Combine the two buffers
424 imageBuffer = CombineImageBuffer( imageBuffer, underlineImageBuffer, bufferWidth, bufferHeight );
427 // Generate the background if enabled
428 const bool backgroundEnabled = mModel->IsBackgroundEnabled();
429 if ( backgroundEnabled )
431 Devel::PixelBuffer backgroundImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_BACKGROUND, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs -1 );
433 // Combine the two buffers
434 imageBuffer = CombineImageBuffer( imageBuffer, backgroundImageBuffer, bufferWidth, bufferHeight );
438 // Create the final PixelData for the combined image buffer
439 PixelData pixelData = Devel::PixelBuffer::Convert( imageBuffer );
444 Devel::PixelBuffer Typesetter::CreateImageBuffer( const unsigned int bufferWidth, const unsigned int bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset, GlyphIndex fromGlyphIndex, GlyphIndex toGlyphIndex )
446 // Retrieve lines, glyphs, positions and colors from the view model.
447 const Length modelNumberOfLines = mModel->GetNumberOfLines();
448 const LineRun* const modelLinesBuffer = mModel->GetLines();
449 const Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
450 const GlyphInfo* const glyphsBuffer = mModel->GetGlyphs();
451 const Vector2* const positionBuffer = mModel->GetLayout();
452 const Vector4* const colorsBuffer = mModel->GetColors();
453 const ColorIndex* const colorIndexBuffer = mModel->GetColorIndices();
455 // Whether to use the default color.
456 const bool useDefaultColor = ( NULL == colorsBuffer );
457 const Vector4& defaultColor = mModel->GetDefaultColor();
459 // Create and initialize the pixel buffer.
461 glyphData.verticalOffset = verticalOffset;
462 glyphData.width = bufferWidth;
463 glyphData.height = bufferHeight;
464 glyphData.bitmapBuffer = Devel::PixelBuffer::New( bufferWidth, bufferHeight, pixelFormat );
465 glyphData.horizontalOffset = 0;
467 if ( Pixel::RGBA8888 == pixelFormat )
469 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
470 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
471 memset( glyphData.bitmapBuffer.GetBuffer(), 0u, bufferSizeChar );
475 memset( glyphData.bitmapBuffer.GetBuffer(), 0, bufferWidth * bufferHeight );
478 // Get a handle of the font client. Used to retrieve the bitmaps of the glyphs.
479 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
481 // Traverses the lines of the text.
482 for( LineIndex lineIndex = 0u; lineIndex < modelNumberOfLines; ++lineIndex )
484 const LineRun& line = *( modelLinesBuffer + lineIndex );
486 // Sets the horizontal offset of the line.
487 glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int>( line.alignmentOffset );
488 glyphData.horizontalOffset += horizontalOffset;
490 // Increases the vertical offset with the line's ascender.
491 glyphData.verticalOffset += static_cast<int>( line.ascender );
493 // Include line spacing after first line
496 glyphData.verticalOffset += static_cast<int>( line.lineSpacing );
499 // Retrieves the glyph's outline width
500 float outlineWidth = mModel->GetOutlineWidth();
502 if( style == Typesetter::STYLE_OUTLINE )
504 glyphData.horizontalOffset -= outlineWidth;
505 if( lineIndex == 0u )
507 // Only need to add the vertical outline offset for the first line
508 glyphData.verticalOffset -= outlineWidth;
511 else if ( style == Typesetter::STYLE_SHADOW )
513 const Vector2& shadowOffset = mModel->GetShadowOffset();
514 glyphData.horizontalOffset += shadowOffset.x - outlineWidth; // if outline enabled then shadow should offset from outline
516 if ( lineIndex == 0u )
518 // Only need to add the vertical shadow offset for first line
519 glyphData.verticalOffset += shadowOffset.y - outlineWidth;
523 const bool underlineEnabled = mModel->IsUnderlineEnabled();
524 const Vector4& underlineColor = mModel->GetUnderlineColor();
525 const float underlineHeight = mModel->GetUnderlineHeight();
527 // Get the underline runs.
528 const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns();
529 Vector<GlyphRun> underlineRuns;
530 underlineRuns.Resize( numberOfUnderlineRuns );
531 mModel->GetUnderlineRuns( underlineRuns.Begin(), 0u, numberOfUnderlineRuns );
533 bool thereAreUnderlinedGlyphs = false;
535 float currentUnderlinePosition = 0.0f;
536 float currentUnderlineThickness = underlineHeight;
537 float maxUnderlineThickness = currentUnderlineThickness;
539 FontId lastUnderlinedFontId = 0;
541 float lineExtentLeft = bufferWidth;
542 float lineExtentRight = 0.0f;
543 float baseline = 0.0f;
545 // Traverses the glyphs of the line.
546 const GlyphIndex endGlyphIndex = std::min( numberOfGlyphs, line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs );
547 for( GlyphIndex glyphIndex = line.glyphRun.glyphIndex; glyphIndex < endGlyphIndex; ++glyphIndex )
549 if ( glyphIndex < fromGlyphIndex || glyphIndex > toGlyphIndex )
551 // Ignore any glyph that out of the specified range
555 // Retrieve the glyph's info.
556 const GlyphInfo* const glyphInfo = glyphsBuffer + glyphIndex;
558 if( ( glyphInfo->width < Math::MACHINE_EPSILON_1000 ) ||
559 ( glyphInfo->height < Math::MACHINE_EPSILON_1000 ) )
561 // Nothing to do if the glyph's width or height is zero.
565 const bool underlineGlyph = underlineEnabled || IsGlyphUnderlined( glyphIndex, underlineRuns );
566 thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || underlineGlyph;
568 // Are we still using the same fontId as previous
569 if( underlineGlyph && ( glyphInfo->fontId != lastUnderlinedFontId ) )
571 // We need to fetch fresh font underline metrics
572 FontMetrics fontMetrics;
573 fontClient.GetFontMetrics( glyphInfo->fontId, fontMetrics );
574 currentUnderlinePosition = ceil( fabsf( fontMetrics.underlinePosition ) );
575 const float descender = ceil( fabsf( fontMetrics.descender ) );
577 if( fabsf( underlineHeight ) < Math::MACHINE_EPSILON_1000 )
579 currentUnderlineThickness = fontMetrics.underlineThickness;
581 // Ensure underline will be at least a pixel high
582 if ( currentUnderlineThickness < 1.0f )
584 currentUnderlineThickness = 1.0f;
588 currentUnderlineThickness = ceil( currentUnderlineThickness );
592 // The underline thickness should be the max underline thickness of all glyphs of the line.
593 if ( currentUnderlineThickness > maxUnderlineThickness )
595 maxUnderlineThickness = currentUnderlineThickness;
598 // Clamp the underline position at the font descender and check for ( as EFL describes it ) a broken font
599 if( currentUnderlinePosition > descender )
601 currentUnderlinePosition = descender;
604 if( fabsf( currentUnderlinePosition ) < Math::MACHINE_EPSILON_1000 )
606 // Move offset down by one ( EFL behavior )
607 currentUnderlinePosition = 1.0f;
610 lastUnderlinedFontId = glyphInfo->fontId;
613 // Retrieves the glyph's position.
614 const Vector2* const position = positionBuffer + glyphIndex;
615 if ( baseline < position->y + glyphInfo->yBearing )
617 baseline = position->y + glyphInfo->yBearing;
620 // Calculate the positions of leftmost and rightmost glyphs in the current line
621 if ( position->x < lineExtentLeft)
623 lineExtentLeft = position->x;
626 if ( position->x + glyphInfo->width > lineExtentRight)
628 lineExtentRight = position->x + glyphInfo->width;
631 // Retrieves the glyph's color.
632 const ColorIndex colorIndex = *( colorIndexBuffer + glyphIndex );
634 const Vector4* color;
635 if ( style == Typesetter::STYLE_SHADOW )
637 color = &( mModel->GetShadowColor() );
639 else if ( style == Typesetter::STYLE_OUTLINE )
641 color = &( mModel->GetOutlineColor() );
645 color = ( useDefaultColor || ( 0u == colorIndex ) ) ? &defaultColor : colorsBuffer + ( colorIndex - 1u );
648 // Retrieves the glyph's bitmap.
649 glyphData.glyphBitmap.buffer = NULL;
650 glyphData.glyphBitmap.width = glyphInfo->width; // Desired width and height.
651 glyphData.glyphBitmap.height = glyphInfo->height;
653 if( style != Typesetter::STYLE_OUTLINE && style != Typesetter::STYLE_SHADOW )
655 // Don't render outline for other styles
658 if( style != Typesetter::STYLE_UNDERLINE )
660 fontClient.CreateBitmap( glyphInfo->fontId,
662 glyphData.glyphBitmap,
667 // Sets the glyph's bitmap into the bitmap of the whole text.
668 if( NULL != glyphData.glyphBitmap.buffer )
670 TypesetGlyph( glyphData,
675 // delete the glyphBitmap.buffer as it is now copied into glyphData.bitmapBuffer
676 delete []glyphData.glyphBitmap.buffer;
677 glyphData.glyphBitmap.buffer = NULL;
681 // Draw the underline from the leftmost glyph to the rightmost glyph
682 if ( thereAreUnderlinedGlyphs && style == Typesetter::STYLE_UNDERLINE )
684 int underlineYOffset = glyphData.verticalOffset + baseline + currentUnderlinePosition;
686 for( unsigned int y = underlineYOffset; y < underlineYOffset + maxUnderlineThickness; y++ )
688 if( y > bufferHeight - 1 )
690 // Do not write out of bounds.
694 for( unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++ )
696 if( x > bufferWidth - 1 )
698 // Do not write out of bounds.
702 // Always RGBA image for text with styles
703 uint32_t* bitmapBuffer = reinterpret_cast< uint32_t* >( glyphData.bitmapBuffer.GetBuffer() );
704 uint32_t underlinePixel = *( bitmapBuffer + y * glyphData.width + x );
705 uint8_t* underlinePixelBuffer = reinterpret_cast<uint8_t*>( &underlinePixel );
707 // Write the underline color to the pixel buffer
708 *( underlinePixelBuffer ) = static_cast<uint8_t>( underlineColor.r * 255.f );
709 *( underlinePixelBuffer + 1u ) = static_cast<uint8_t>( underlineColor.g * 255.f );
710 *( underlinePixelBuffer + 2u ) = static_cast<uint8_t>( underlineColor.b * 255.f );
711 *( underlinePixelBuffer + 3u ) = static_cast<uint8_t>( underlineColor.a * 255.f );
713 *( bitmapBuffer + y * glyphData.width + x ) = underlinePixel;
718 // Draw the background color from the leftmost glyph to the rightmost glyph
719 if ( style == Typesetter::STYLE_BACKGROUND )
721 Vector4 backgroundColor = mModel->GetBackgroundColor();
723 for( int y = glyphData.verticalOffset + baseline - line.ascender; y < glyphData.verticalOffset + baseline - line.descender; y++ )
725 if( ( y < 0 ) || ( y > static_cast<int>(bufferHeight - 1) ) )
727 // Do not write out of bounds.
731 for( int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++ )
733 if( ( x < 0 ) || ( x > static_cast<int>(bufferWidth - 1) ) )
735 // Do not write out of bounds.
739 // Always RGBA image for text with styles
740 uint32_t* bitmapBuffer = reinterpret_cast< uint32_t* >( glyphData.bitmapBuffer.GetBuffer() );
741 uint32_t backgroundPixel = *( bitmapBuffer + y * glyphData.width + x );
742 uint8_t* backgroundPixelBuffer = reinterpret_cast<uint8_t*>( &backgroundPixel );
744 // Write the background color to the pixel buffer
745 *( backgroundPixelBuffer ) = static_cast<uint8_t>( backgroundColor.r * 255.f );
746 *( backgroundPixelBuffer + 1u ) = static_cast<uint8_t>( backgroundColor.g * 255.f );
747 *( backgroundPixelBuffer + 2u ) = static_cast<uint8_t>( backgroundColor.b * 255.f );
748 *( backgroundPixelBuffer + 3u ) = static_cast<uint8_t>( backgroundColor.a * 255.f );
750 *( bitmapBuffer + y * glyphData.width + x ) = backgroundPixel;
755 // Increases the vertical offset with the line's descender.
756 glyphData.verticalOffset += static_cast<int>( -line.descender );
759 return glyphData.bitmapBuffer;
762 Devel::PixelBuffer Typesetter::CombineImageBuffer( Devel::PixelBuffer topPixelBuffer, Devel::PixelBuffer bottomPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight )
764 unsigned char* topBuffer = topPixelBuffer.GetBuffer();
765 unsigned char* bottomBuffer = bottomPixelBuffer.GetBuffer();
767 Devel::PixelBuffer combinedPixelBuffer;
769 if ( topBuffer == NULL && bottomBuffer == NULL )
771 // Nothing to do if both buffers are empty.
772 return combinedPixelBuffer;
775 if ( topBuffer == NULL )
777 // Nothing to do if topBuffer is empty.
778 return bottomPixelBuffer;
781 if ( bottomBuffer == NULL )
783 // Nothing to do if bottomBuffer is empty.
784 return topPixelBuffer;
787 // Always combine two RGBA images
788 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
789 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
791 combinedPixelBuffer = Devel::PixelBuffer::New( bufferWidth, bufferHeight, Pixel::RGBA8888 );
792 uint8_t* combinedBuffer = reinterpret_cast< uint8_t* >( combinedPixelBuffer.GetBuffer() );
793 memset( combinedBuffer, 0u, bufferSizeChar );
795 for (unsigned int pixelIndex = 0; pixelIndex < bufferSizeInt; pixelIndex++)
797 // If the alpha of the pixel in either buffer is not fully opaque, blend the two pixels.
798 // Otherwise, copy pixel from topBuffer to combinedBuffer.
800 unsigned int alphaBuffer1 = topBuffer[pixelIndex*4+3];
801 unsigned int alphaBuffer2 = bottomBuffer[pixelIndex*4+3];
803 if ( alphaBuffer1 != 255 || alphaBuffer2 != 255 )
805 // At least one pixel is not fully opaque
806 // "Over" blend the the pixel from topBuffer with the pixel in bottomBuffer
807 combinedBuffer[pixelIndex*4] = ( topBuffer[pixelIndex*4] * topBuffer[pixelIndex*4+3] / 255 ) + ( bottomBuffer[pixelIndex*4] * bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / ( 255*255 ) );
808 combinedBuffer[pixelIndex*4+1] = ( topBuffer[pixelIndex*4+1] * topBuffer[pixelIndex*4+3] / 255 ) + ( bottomBuffer[pixelIndex*4+1] * bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / ( 255*255 ) );
809 combinedBuffer[pixelIndex*4+2] = ( topBuffer[pixelIndex*4+2] * topBuffer[pixelIndex*4+3] / 255 ) + ( bottomBuffer[pixelIndex*4+2] * bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / ( 255*255 ) );
810 combinedBuffer[pixelIndex*4+3] = topBuffer[pixelIndex*4+3] + ( bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / 255 );
814 // Copy the pixel from topBuffer to combinedBuffer
815 combinedBuffer[pixelIndex*4] = topBuffer[pixelIndex*4];
816 combinedBuffer[pixelIndex*4+1] = topBuffer[pixelIndex*4+1];
817 combinedBuffer[pixelIndex*4+2] = topBuffer[pixelIndex*4+2];
818 combinedBuffer[pixelIndex*4+3] = topBuffer[pixelIndex*4+3];
822 return combinedPixelBuffer;
825 Typesetter::Typesetter( const ModelInterface* const model )
826 : mModel( new ViewModel( model ) )
830 Typesetter::~Typesetter()
837 } // namespace Toolkit