| Flutter Impeller |

Public Member Functions | Static Public Member Functions | List of all members
impeller::TextContents Class Referencefinal

`#include <text_contents.h>`

Inheritance diagram for impeller::TextContents:

## Public Member Functions
| TextContents ()
| ~TextContents ()
void | SetTextFrame (const std::shared_ptr< TextFrame > &frame)
void | SetColor (Color color)
void | SetForceTextColor (bool value)
| Force the text color to apply to the rendered glyphs, even if those glyphs are bitmaps. More...
void | SetTextProperties (Color color, bool stroke, Scalar stroke_width, Cap stroke_cap, Join stroke_join, Scalar stroke_miter)
| Must be set after text frame. More...
Color | GetColor () const
void | SetInheritedOpacity (Scalar opacity) override
| Inherit the provided opacity. More...
void | SetOffset (Vector2 offset)
std::optional< Rect > | GetTextFrameBounds () const
std::optional< Rect > | GetCoverage (const Entity &entity) const override
| Get the area of the render pass that will be affected when this contents is rendered. More...
void | SetScale (Scalar scale)
bool | Render (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
Public Member Functions inherited from impeller::Contents
| Contents ()
virtual | ~Contents ()
void | SetCoverageHint (std::optional< Rect > coverage_hint)
| Hint that specifies the coverage area of this Contents that will actually be used during rendering. This is for optimization purposes only and can not be relied on as a clip. May optionally affect the result of `GetCoverage()`. More...
const std::optional< Rect > & | GetCoverageHint () const
virtual bool | IsOpaque (const Matrix &transform) const
| Whether this Contents only emits opaque source colors from the fragment stage. This value does not account for any entity properties (e.g. the blend mode), clips/visibility culling, or inherited opacity. More...
virtual std::optional< Snapshot > | RenderToSnapshot (const ContentContext &renderer, const Entity &entity, std::optional< Rect > coverage_limit=std::nullopt, const std::optional< SamplerDescriptor > &sampler_descriptor=std::nullopt, bool msaa_enabled=true, int32_t mip_count=1, std::string_view label="Snapshot") const
| Render this contents to a snapshot, respecting the entity's transform, path, clip depth, and blend mode. The result texture size is always the size of `GetCoverage(entity)`. More...
std::optional< Size > | GetColorSourceSize () const
| Return the color source's intrinsic size, if available. More...
void | SetColorSourceSize (Size size)
virtual std::optional< Color > | AsBackgroundColor (const Entity &entity, ISize target_size) const
| Returns a color if this Contents will flood the given `target_size` with a color. This output color is the "Source" color that will be used for the Entity's blend operation. More...
virtual bool | ApplyColorFilter (const ColorFilterProc &color_filter_proc)
| If possible, applies a color filter to this contents inputs on the CPU. More...

## Static Public Member Functions
static void | ComputeVertexData (GlyphAtlasPipeline::VertexShader::PerVertexData *vtx_contents, const std::shared_ptr< TextFrame > &frame, Scalar scale, const Matrix &entity_transform, Vector2 offset, std::optional< GlyphProperties > glyph_properties, const std::shared_ptr< GlyphAtlas > &atlas)
Static Public Member Functions inherited from impeller::Contents
static std::shared_ptr< Contents > | MakeAnonymous (RenderProc render_proc, CoverageProc coverage_proc)

## Additional Inherited Members
Public Types inherited from impeller::Contents
using | ColorFilterProc = std::function< Color(Color)>
using | RenderProc = std::function< bool(const ContentContext &renderer, const Entity &entity, RenderPass &pass)>
using | CoverageProc = std::function< std::optional< Rect >(const Entity &entity)>

## Detailed Description

Definition at line 21 of file text_contents.h.

## Constructor & Destructor Documentation

## ◆ TextContents()

impeller::TextContents::TextContents | ( |  | ) |
| default

## ◆ ~TextContents()

impeller::TextContents::~TextContents | ( |  | ) |
| default

## Member Function Documentation

## ◆ ComputeVertexData()

void impeller::TextContents::ComputeVertexData | ( | GlyphAtlasPipeline::VertexShader::PerVertexData * | vtx_contents,
|  | const std::shared_ptr< TextFrame > & | frame,
|  | Scalar | scale,
|  | const Matrix & | entity_transform,
|  | Vector2 | offset,
|  | std::optional< GlyphProperties > | glyph_properties,
|  | const std::shared_ptr< GlyphAtlas > & | atlas
| ) |  |
| static

Definition at line 96 of file text_contents.cc.

103 {
104 // Common vertex information for all glyphs.
105 // All glyphs are given the same vertex information in the form of a
106 // unit-sized quad. The size of the glyph is specified in per instance data
107 // and the vertex shader uses this to size the glyph correctly. The
108 // interpolated vertex information is also used in the fragment shader to
109 // sample from the glyph atlas.
110
111 constexpr std::array<Point, 6> unit_points = {Point{0, 0}, Point{1, 0},
112 Point{0, 1}, Point{1, 0},
113 Point{0, 1}, Point{1, 1}};
114
115 ISize atlas_size = atlas->GetTexture()->GetSize();
116 bool is_translation_scale = entity_transform.IsTranslationScaleOnly();
117 Matrix basis_transform = entity_transform.Basis();
118
119 VS::PerVertexData vtx;
120 size_t i = 0u;
121 size_t bounds_offset = 0u;
122 for (const TextRun& run : frame->GetRuns()) {
123 const Font& font = run.GetFont();
124 Scalar rounded_scale = frame->GetScale();
125 const Matrix transform = frame->GetOffsetTransform();
126 FontGlyphAtlas* font_atlas = nullptr;
127
128 // Adjust glyph position based on the subpixel rounding
129 // used by the font.
130 Point subpixel_adjustment(0.5, 0.5);
131 switch (font.GetAxisAlignment()) {
132 case AxisAlignment::kNone:
133 break;
134 case AxisAlignment::kX:
135 subpixel_adjustment.x = 0.125;
136 break;
137 case AxisAlignment::kY:
138 subpixel_adjustment.y = 0.125;
139 break;
140 case AxisAlignment::kAll:
141 subpixel_adjustment.x = 0.125;
142 subpixel_adjustment.y = 0.125;
143 break;
144 }
145
146 Point screen_offset = (entity_transform * Point(0, 0));
147 for (const TextRun::GlyphPosition& glyph_position :
148 run.GetGlyphPositions()) {
149 const FrameBounds& frame_bounds = frame->GetFrameBounds(bounds_offset);
150 bounds_offset++;
151 auto atlas_glyph_bounds = frame_bounds.atlas_bounds;
152 auto glyph_bounds = frame_bounds.glyph_bounds;
153
154 // If frame_bounds.is_placeholder is true, this is the first frame
155 // the glyph has been rendered and so its atlas position was not
156 // known when the glyph was recorded. Perform a slow lookup into the
157 // glyph atlas hash table.
158 if (frame_bounds.is_placeholder) {
159 if (!font_atlas) {
160 font_atlas =
161 atlas->GetOrCreateFontGlyphAtlas(ScaledFont{font, rounded_scale});
162 }
163
164 if (!font_atlas) {
165 VALIDATION_LOG << "Could not find font in the atlas.";
166 continue;
167 }
168 Point subpixel = TextFrame::ComputeSubpixelPosition(
169 glyph_position, font.GetAxisAlignment(), transform);
170
171 std::optional<FrameBounds> maybe_atlas_glyph_bounds =
172 font_atlas->FindGlyphBounds(SubpixelGlyph{
173 glyph_position.glyph, //
174 subpixel, //
175 glyph_properties //
176 });
177 if (!maybe_atlas_glyph_bounds.has_value()) {
178 VALIDATION_LOG << "Could not find glyph position in the atlas.";
179 continue;
180 }
181 atlas_glyph_bounds = maybe_atlas_glyph_bounds.value().atlas_bounds;
182 }
183
184 Scalar inverted_rounded_scale = 1.f / rounded_scale;
185 Rect scaled_bounds = glyph_bounds.Scale(inverted_rounded_scale);
186 // For each glyph, we compute two rectangles. One for the vertex
187 // positions and one for the texture coordinates (UVs). The atlas
188 // glyph bounds are used to compute UVs in cases where the
189 // destination and source sizes may differ due to clamping the sizes
190 // of large glyphs.
191 Point uv_origin = (atlas_glyph_bounds.GetLeftTop()) / atlas_size;
192 Point uv_size = SizeToPoint(atlas_glyph_bounds.GetSize()) / atlas_size;
193
194 Matrix unscaled_basis =
195 basis_transform * Matrix::MakeScale({inverted_rounded_scale,
196 inverted_rounded_scale, 1});
197
198 // In typical scales < 48x these values should be -1 or 1. We round to
199 // those to avoid inaccuracies.
200 unscaled_basis.m[0] = AttractToOne(unscaled_basis.m[0]);
201 unscaled_basis.m[5] = AttractToOne(unscaled_basis.m[5]);
202
203 Point unrounded_glyph_position =
204 // This is for RTL text.
205 unscaled_basis * glyph_bounds.GetLeftTop() +
206 (basis_transform * glyph_position.position);
207
208 Point screen_glyph_position =
209 (screen_offset + unrounded_glyph_position + subpixel_adjustment)
210 .Floor();
211 for (const Point& point : unit_points) {
212 Point position;
213 if (is_translation_scale) {
214 position = (screen_glyph_position +
215 (unscaled_basis * point * glyph_bounds.GetSize()))
216 .Round();
217 } else {
218 position = entity_transform *
219 (glyph_position.position + scaled_bounds.GetLeftTop() +
220 point * scaled_bounds.GetSize());
221 }
222 vtx.uv = uv_origin + (uv_size * point);
223 vtx.position = position;
224 vtx_contents[i++] = vtx;
225 }
226 }
227 }
228 }
impeller::TextFrame::ComputeSubpixelPosition
static Point ComputeSubpixelPosition(const TextRun::GlyphPosition &glyph_position, AxisAlignment alignment, const Matrix &transform)
Definition: text_frame.cc:69
transform
Matrix transform
Definition: gaussian_blur_filter_contents.cc:214
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::Rect
TRect< Scalar > Rect
Definition: rect.h:792
impeller::Point
TPoint< Scalar > Point
Definition: point.h:327
impeller::AxisAlignment::kX
@ kX
impeller::AxisAlignment::kAll
@ kAll
impeller::AxisAlignment::kNone
@ kNone
impeller::AxisAlignment::kY
@ kY
impeller::SizeToPoint
Point SizeToPoint(Size size)
Definition: text_contents.cc:21
impeller::ISize
ISize64 ISize
Definition: size.h:174
vtx
SolidFillVertexShader::PerVertexData vtx
Definition: stroke_path_geometry.cc:320
impeller::Matrix::m
Scalar m[16]
Definition: matrix.h:39
impeller::Matrix::MakeScale
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
impeller::TPoint::Round
static constexpr TPoint Round(const TPoint< U > &other)
Definition: point.h:49
impeller::TRect::Scale
constexpr TRect Scale(Type scale) const
Definition: rect.h:206
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:91

References impeller::FrameBounds::atlas_bounds, impeller::Matrix::Basis(), impeller::TextFrame::ComputeSubpixelPosition(), impeller::FontGlyphAtlas::FindGlyphBounds(), impeller::Font::GetAxisAlignment(), impeller::TRect< T >::GetLeftTop(), impeller::TRect< T >::GetSize(), impeller::SubpixelGlyph::glyph, impeller::FrameBounds::glyph_bounds, impeller::FrameBounds::is_placeholder, impeller::Matrix::IsTranslationScaleOnly(), impeller::kAll, impeller::kNone, impeller::kX, impeller::kY, impeller::Matrix::m, impeller::Matrix::MakeScale(), impeller::TPoint< T >::Round(), impeller::TRect< T >::Scale(), impeller::SizeToPoint(), transform, VALIDATION_LOG, vtx, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by Render(), and impeller::testing::TEST_P().

## ◆ GetColor()

Color impeller::TextContents::GetColor | ( |  | ) | const

Definition at line 40 of file text_contents.cc.

40 {
41 return color_.WithAlpha(color_.alpha * inherited_opacity_);
42 }
impeller::Color::alpha
Scalar alpha
Definition: color.h:142
impeller::Color::WithAlpha
constexpr Color WithAlpha(Scalar new_alpha) const
Definition: color.h:277

References impeller::Color::alpha, and impeller::Color::WithAlpha().

Referenced by Render().

## ◆ GetCoverage()

std::optional< Rect > impeller::TextContents::GetCoverage | ( | const Entity & | entity | ) | const
| override virtual

Get the area of the render pass that will be affected when this contents is rendered.

During rendering, coverage coordinates count pixels from the top left corner of the framebuffer.

Returns
  The coverage rectangle. An `std::nullopt` result means that rendering this contents has no effect on the output color.

Implements impeller::Contents.

Definition at line 56 of file text_contents.cc.

56 {
57 return frame_->GetBounds().TransformBounds(entity.GetTransform());
58 }

References impeller::Entity::GetTransform().

## ◆ GetTextFrameBounds()

std::optional<Rect> impeller::TextContents::GetTextFrameBounds | ( |  | ) | const

## ◆ Render()

bool impeller::TextContents::Render | ( | const ContentContext & | renderer,
|  | const Entity & | entity,
|  | RenderPass & | pass
| ) |  | const
| override virtual

Implements impeller::Contents.

Definition at line 230 of file text_contents.cc.

232 {
233 auto color = GetColor();
234 if (color.IsTransparent()) {
235 return true;
236 }
237
238 auto type = frame_->GetAtlasType();
239 const std::shared_ptr<GlyphAtlas>& atlas =
240 renderer.GetLazyGlyphAtlas()->CreateOrGetGlyphAtlas(
241 *renderer.GetContext(), renderer.GetTransientsBuffer(), type);
242
243 if (!atlas || !atlas->IsValid()) {
244 VALIDATION_LOG << "Cannot render glyphs without prepared atlas.";
245 return false;
246 }
247 if (!frame_->IsFrameComplete()) {
248 VALIDATION_LOG << "Failed to find font glyph bounds.";
249 return false;
250 }
251
252 // Information shared by all glyph draw calls.
253 pass.SetCommandLabel("TextFrame");
254 auto opts = OptionsFromPassAndEntity(pass, entity);
255 opts.primitive_type = PrimitiveType::kTriangle;
256 pass.SetPipeline(renderer.GetGlyphAtlasPipeline(opts));
257
258 // Common vertex uniforms for all glyphs.
259 VS::FrameInfo frame_info;
260 frame_info.mvp =
261 Entity::GetShaderTransform(entity.GetShaderClipDepth(), pass, Matrix());
262 bool is_translation_scale = entity.GetTransform().IsTranslationScaleOnly();
263 Matrix entity_transform = entity.GetTransform();
264
265 VS::BindFrameInfo(pass,
266 renderer.GetTransientsBuffer().EmplaceUniform(frame_info));
267
268 FS::FragInfo frag_info;
269 frag_info.use_text_color = force_text_color_ ? 1.0 : 0.0;
270 frag_info.text_color = ToVector(color.Premultiply());
271 frag_info.is_color_glyph = type == GlyphAtlas::Type::kColorBitmap;
272
273 FS::BindFragInfo(pass,
274 renderer.GetTransientsBuffer().EmplaceUniform(frag_info));
275
276 SamplerDescriptor sampler_desc;
277 if (is_translation_scale) {
278 sampler_desc.min_filter = MinMagFilter::kNearest;
279 sampler_desc.mag_filter = MinMagFilter::kNearest;
280 } else {
281 // Currently, we only propagate the scale of the transform to the atlas
282 // renderer, so if the transform has more than just a translation, we turn
283 // on linear sampling to prevent crunchiness caused by the pixel grid not
284 // being perfectly aligned.
285 // The downside is that this slightly over-blurs rotated/skewed text.
286 sampler_desc.min_filter = MinMagFilter::kLinear;
287 sampler_desc.mag_filter = MinMagFilter::kLinear;
288 }
289
290 // No mipmaps for glyph atlas (glyphs are generated at exact scales).
291 sampler_desc.mip_filter = MipFilter::kBase;
292
293 FS::BindGlyphAtlasSampler(
294 pass, // command
295 atlas->GetTexture(), // texture
296 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
297 sampler_desc) // sampler
298 );
299
300 auto& host_buffer = renderer.GetTransientsBuffer();
301 size_t vertex_count = 0;
302 for (const auto& run : frame_->GetRuns()) {
303 vertex_count += run.GetGlyphPositions().size();
304 }
305 vertex_count *= 6;
306
307 BufferView buffer_view = host_buffer.Emplace(
308 vertex_count * sizeof(VS::PerVertexData), alignof(VS::PerVertexData),
309 [&](uint8_t* contents) {
310 VS::PerVertexData* vtx_contents =
311 reinterpret_cast<VS::PerVertexData*>(contents);
312 ComputeVertexData(vtx_contents, frame_, scale_,
313 /*entity_transform=*/entity_transform, offset_,
314 GetGlyphProperties(), atlas);
315 });
316
317 pass.SetVertexBuffer(std::move(buffer_view));
318 pass.SetIndexBuffer({}, IndexType::kNone);
319 pass.SetElementCount(vertex_count);
320
321 return pass.Draw().ok();
322 }
type
GLenum type
Definition: blit_command_gles.cc:151
buffer_view
BufferView buffer_view
Definition: blit_command_gles.cc:152
impeller::Entity::GetShaderTransform
Matrix GetShaderTransform(const RenderPass &pass) const
Get the vertex shader transform used for drawing this Entity.
Definition: entity.cc:48
impeller::GlyphAtlas::Type::kColorBitmap
@ kColorBitmap
impeller::TextContents::ComputeVertexData
static void ComputeVertexData(GlyphAtlasPipeline::VertexShader::PerVertexData *vtx_contents, const std::shared_ptr< TextFrame > &frame, Scalar scale, const Matrix &entity_transform, Vector2 offset, std::optional< GlyphProperties > glyph_properties, const std::shared_ptr< GlyphAtlas > &atlas)
Definition: text_contents.cc:96
impeller::TextContents::GetColor
Color GetColor() const
Definition: text_contents.cc:40
impeller::IndexType::kNone
@ kNone
Does not use the index buffer.
impeller::PrimitiveType::kTriangle
@ kTriangle
impeller::MipFilter::kBase
@ kBase
The texture is sampled as if it only had a single mipmap level.
impeller::ToVector
constexpr Vector4 ToVector(Color color)
Definition: shader_types.h:190
impeller::OptionsFromPassAndEntity
ContentContextOptions OptionsFromPassAndEntity(const RenderPass &pass, const Entity &entity)
Definition: contents.cc:34
impeller::MinMagFilter::kLinear
@ kLinear
impeller::MinMagFilter::kNearest
@ kNearest
Select nearest to the sample point. Most widely supported.

References buffer_view, ComputeVertexData(), impeller::RenderPass::Draw(), impeller::HostBuffer::EmplaceUniform(), GetColor(), impeller::ContentContext::GetContext(), impeller::ContentContext::GetGlyphAtlasPipeline(), impeller::ContentContext::GetLazyGlyphAtlas(), impeller::Entity::GetShaderClipDepth(), impeller::Entity::GetShaderTransform(), impeller::Entity::GetTransform(), impeller::ContentContext::GetTransientsBuffer(), impeller::Matrix::IsTranslationScaleOnly(), impeller::kBase, impeller::GlyphAtlas::kColorBitmap, impeller::kLinear, impeller::kNearest, impeller::kNone, impeller::kTriangle, impeller::SamplerDescriptor::mag_filter, impeller::SamplerDescriptor::min_filter, impeller::SamplerDescriptor::mip_filter, impeller::OptionsFromPassAndEntity(), impeller::RenderPass::SetCommandLabel(), impeller::RenderPass::SetElementCount(), impeller::RenderPass::SetIndexBuffer(), impeller::RenderPass::SetPipeline(), impeller::RenderPass::SetVertexBuffer(), impeller::ToVector(), type, and VALIDATION_LOG.

Referenced by impeller::testing::TEST_P().

## ◆ SetColor()

void impeller::TextContents::SetColor | ( | Color | color | ) |

Definition at line 36 of file text_contents.cc.

36 {
37 color_ = color;
38 }

Referenced by impeller::testing::TEST_P().

## ◆ SetForceTextColor()

void impeller::TextContents::SetForceTextColor | ( | bool | value | ) |

Force the text color to apply to the rendered glyphs, even if those glyphs are bitmaps.

This is used to ensure that mask blurs work correctly on emoji.

Definition at line 52 of file text_contents.cc.

52 {
53 force_text_color_ = value;
54 }
value
int32_t value
Definition: dl_golden_unittests.cc:444

References value.

## ◆ SetInheritedOpacity()

void impeller::TextContents::SetInheritedOpacity | ( | Scalar | opacity | ) |
| override virtual

Inherit the provided opacity.

       Use of this method is invalid if CanAcceptOpacity returns false.

Reimplemented from impeller::Contents.

Definition at line 44 of file text_contents.cc.

44 {
45 inherited_opacity_ = opacity;
46 }

## ◆ SetOffset()

void impeller::TextContents::SetOffset | ( | Vector2 | offset | ) |

Definition at line 48 of file text_contents.cc.

48 {
49 offset_ = offset;
50 }
offset
SeparatedVector2 offset
Definition: stroke_path_geometry.cc:319

References offset.

Referenced by impeller::testing::TEST_P().

## ◆ SetScale()

void impeller::TextContents::SetScale | ( | Scalar | scale | ) |
| inline

Definition at line 58 of file text_contents.h.

58 { scale_ = scale; }
scale
const Scalar scale
Definition: stroke_path_geometry.cc:316

References scale.

Referenced by impeller::testing::TEST_P().

## ◆ SetTextFrame()

void impeller::TextContents::SetTextFrame | ( | const std::shared_ptr< TextFrame > & | frame | ) |

Definition at line 32 of file text_contents.cc.

32 {
33 frame_ = frame;
34 }

Referenced by impeller::testing::TEST_P().

## ◆ SetTextProperties()

void impeller::TextContents::SetTextProperties | ( | Color | color,
|  | bool | stroke,
|  | Scalar | stroke_width,
|  | Cap | stroke_cap,
|  | Join | stroke_join,
|  | Scalar | stroke_miter
| ) |  |

Must be set after text frame.

Definition at line 60 of file text_contents.cc.

65 {
66 if (frame_->HasColor()) {
67 // Alpha is always applied when rendering, remove it here so
68 // we do not double-apply the alpha.
69 properties_.color = color.WithAlpha(1.0);
70 }
71 if (stroke) {
72 properties_.stroke = true;
73 properties_.stroke_width = stroke_width;
74 properties_.stroke_cap = stroke_cap;
75 properties_.stroke_join = stroke_join;
76 properties_.stroke_miter = stroke_miter;
77 }
78 }
stroke_width
const Scalar stroke_width
Definition: stroke_path_geometry.cc:312
impeller::GlyphProperties::color
Color color
Definition: font_glyph_pair.h:17
impeller::GlyphProperties::stroke_cap
Cap stroke_cap
Definition: font_glyph_pair.h:19
impeller::GlyphProperties::stroke_width
Scalar stroke_width
Definition: font_glyph_pair.h:18
impeller::GlyphProperties::stroke_join
Join stroke_join
Definition: font_glyph_pair.h:20
impeller::GlyphProperties::stroke_miter
Scalar stroke_miter
Definition: font_glyph_pair.h:21
impeller::GlyphProperties::stroke
bool stroke
Definition: font_glyph_pair.h:22

References impeller::GlyphProperties::color, impeller::GlyphProperties::stroke, impeller::GlyphProperties::stroke_cap, impeller::GlyphProperties::stroke_join, impeller::GlyphProperties::stroke_miter, stroke_width, impeller::GlyphProperties::stroke_width, and impeller::Color::WithAlpha().

The documentation for this class was generated from the following files:

- impeller/entity/contents/text_contents.h
- impeller/entity/contents/text_contents.cc