| Flutter Impeller |

linear_gradient_contents.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "linear_gradient_contents.h"
6
7 #include "impeller/core/formats.h"
8 #include "impeller/entity/contents/content_context.h"
9 #include "impeller/entity/contents/gradient_generator.h"
10 #include "impeller/entity/entity.h"
11 #include "impeller/entity/geometry/geometry.h"
12 #include "impeller/geometry/scalar.h"
13 #include "impeller/renderer/render_pass.h"
14 #include "impeller/renderer/vertex_buffer_builder.h"
15
16 namespace impeller {
17
18 LinearGradientContents::LinearGradientContents() = default;
19
20 LinearGradientContents::~LinearGradientContents() = default;
21
22 void LinearGradientContents::SetEndPoints(Point start_point, Point end_point) {
23 start_point_ = start_point;
24 end_point_ = end_point;
25 }
26
27 void LinearGradientContents::SetColors(std::vector<Color> colors) {
28 colors_ = std::move(colors);
29 }
30
31 void LinearGradientContents::SetStops(std::vector<Scalar> stops) {
32 stops_ = std::move(stops);
33 }
34
35 const std::vector<Color>& LinearGradientContents::GetColors() const {
36 return colors_;
37 }
38
39 const std::vector<Scalar>& LinearGradientContents::GetStops() const {
40 return stops_;
41 }
42
43 void LinearGradientContents::SetTileMode(Entity::TileMode tile_mode) {
44 tile_mode_ = tile_mode;
45 }
46
47 bool LinearGradientContents::IsOpaque(const Matrix& transform) const {
48 if (GetOpacityFactor() < 1 || tile_mode_ == Entity::TileMode::kDecal) {
49 return false;
50 }
51 for (auto color : colors_) {
52 if (!color.IsOpaque()) {
53 return false;
54 }
55 }
56 return !AppliesAlphaForStrokeCoverage(transform);
57 }
58
59 bool LinearGradientContents::CanApplyFastGradient() const {
60 if (!GetInverseEffectTransform().IsIdentity()) {
61 return false;
62 }
63 std::optional<Rect> maybe_rect = GetGeometry()->GetCoverage(Matrix());
64 if (!maybe_rect.has_value()) {
65 return false;
66 }
67 Rect rect = maybe_rect.value();
68
69 if (ScalarNearlyEqual(start_point_.x, end_point_.x)) {
70 // Sort start and end to make on-rect comparisons easier.
71 Point start = (start_point_.y < end_point_.y) ? start_point_ : end_point_;
72 Point end = (start_point_.y < end_point_.y) ? end_point_ : start_point_;
73 // The exact x positon doesn't matter for a vertical gradient, but the y
74 // position must be nearly on the rectangle.
75 if (ScalarNearlyEqual(start.y, rect.GetTop()) &&
76 ScalarNearlyEqual(end.y, rect.GetBottom())) {
77 return true;
78 }
79 return false;
80 }
81
82 if (ScalarNearlyEqual(start_point_.y, end_point_.y)) {
83 // Sort start and end to make on-rect comparisons easier.
84 Point start = (start_point_.x < end_point_.x) ? start_point_ : end_point_;
85 Point end = (start_point_.x < end_point_.x) ? end_point_ : start_point_;
86 // The exact y positon doesn't matter for a horizontal gradient, but the x
87 // position must be nearly on the rectangle.
88 if (ScalarNearlyEqual(start.x, rect.GetLeft()) &&
89 ScalarNearlyEqual(end.x, rect.GetRight())) {
90 return true;
91 }
92 return false;
93 }
94
95 return false;
96 }
97
98 // A much faster (in terms of ALU) linear gradient that uses vertex
99 // interpolation to perform all color computation. Requires that the geometry of
100 // the gradient is divided into regions based on the stop values.
101 // Currently restricted to rect geometry where the start and end points are
102 // perfectly horizontal/vertical, but could easily be expanded to StC cases
103 // provided that the start/end are on or outside of the coverage rect.
104 bool LinearGradientContents::FastLinearGradient(const ContentContext& renderer,
105 const Entity& entity,
106 RenderPass& pass) const {
107 using VS = FastGradientPipeline::VertexShader;
108 using FS = FastGradientPipeline::FragmentShader;
109
110 const Geometry* geometry = GetGeometry();
111 bool force_stencil = !geometry->IsAxisAlignedRect();
112
113 auto geom_callback = [&](const ContentContext& renderer, const Entity& entity,
114 RenderPass& pass,
115 const Geometry* geometry) -> GeometryResult {
116 // We already know this is an axis aligned rectangle, so the coverage will
117 // be approximately the same as the geometry. For non axis-algined
118 // rectangles, we can force stencil then cover (not done here). We give an
119 // identity transform to avoid double transforming the gradient.
120 std::optional<Rect> maybe_rect = geometry->GetCoverage(Matrix());
121 if (!maybe_rect.has_value()) {
122 return {};
123 }
124 Rect rect = maybe_rect.value();
125 bool horizontal_axis = start_point_.y == end_point_.y;
126
127 // Compute the locations of each breakpoint along the primary axis, then
128 // create a rectangle that joins each segment. There will be two triangles
129 // between each pair of points.
130 VertexBufferBuilder<VS::PerVertexData> vtx_builder;
131 vtx_builder.Reserve(6 * (stops_.size() - 1));
132 Point prev = start_point_;
133 for (auto i = 1u; i < stops_.size(); i++) {
134 Scalar t = stops_[i];
135 Point current = (1.0 - t) * start_point_ + t * end_point_;
136 Rect section = horizontal_axis
137 ? Rect::MakeXYWH(prev.x, rect.GetY(),
138 current.x - prev.x, rect.GetHeight())
139
140 : Rect::MakeXYWH(rect.GetX(), prev.y, rect.GetWidth(),
141 current.y - prev.y);
142 vtx_builder.AddVertices({
143 {section.GetLeftTop(), colors_[i - 1]},
144 {section.GetRightTop(),
145 horizontal_axis ? colors_[i] : colors_[i - 1]},
146 {section.GetLeftBottom(),
147 horizontal_axis ? colors_[i - 1] : colors_[i]},
148 {section.GetRightTop(),
149 horizontal_axis ? colors_[i] : colors_[i - 1]},
150 {section.GetLeftBottom(),
151 horizontal_axis ? colors_[i - 1] : colors_[i]},
152 {section.GetRightBottom(), colors_[i]},
153 });
154 prev = current;
155 }
156 return GeometryResult{
157 .type = PrimitiveType::kTriangle,
158 .vertex_buffer =
159 vtx_builder.CreateVertexBuffer(renderer.GetTransientsBuffer()),
160 .transform = entity.GetShaderTransform(pass),
161 };
162 };
163
164 pass.SetLabel("LinearGradient");
165
166 VS::FrameInfo frame_info;
167
168 PipelineBuilderCallback pipeline_callback =
169 [&renderer](ContentContextOptions options) {
170 return renderer.GetFastGradientPipeline(options);
171 };
172 return ColorSourceContents::DrawGeometry<VS>(
173 renderer, entity, pass, pipeline_callback, frame_info,
174 [this, &renderer, &entity](RenderPass& pass) {
175 auto& host_buffer = renderer.GetTransientsBuffer();
176
177 FS::FragInfo frag_info;
178 frag_info.alpha =
179 GetOpacityFactor() *
180 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
181
182 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
183
184 return true;
185 },
186 /*force_stencil=*/force_stencil, geom_callback);
187 }
188
189 bool LinearGradientContents::Render(const ContentContext& renderer,
190 const Entity& entity,
191 RenderPass& pass) const {
192 // TODO(148651): The fast path is overly restrictive, following the design in
193 // https://github.com/flutter/flutter/issues/148651 support for more cases can
194 // be gradually added.
195 if (CanApplyFastGradient()) {
196 return FastLinearGradient(renderer, entity, pass);
197 }
198 if (renderer.GetDeviceCapabilities().SupportsSSBO()) {
199 return RenderSSBO(renderer, entity, pass);
200 }
201 return RenderTexture(renderer, entity, pass);
202 }
203
204 bool LinearGradientContents::RenderTexture(const ContentContext& renderer,
205 const Entity& entity,
206 RenderPass& pass) const {
207 using VS = LinearGradientFillPipeline::VertexShader;
208 using FS = LinearGradientFillPipeline::FragmentShader;
209
210 VS::FrameInfo frame_info;
211 frame_info.matrix = GetInverseEffectTransform();
212
213 PipelineBuilderCallback pipeline_callback =
214 [&renderer](ContentContextOptions options) {
215 return renderer.GetLinearGradientFillPipeline(options);
216 };
217 return ColorSourceContents::DrawGeometry<VS>(
218 renderer, entity, pass, pipeline_callback, frame_info,
219 [this, &renderer, &entity](RenderPass& pass) {
220 auto gradient_data = CreateGradientBuffer(colors_, stops_);
221 auto gradient_texture =
222 CreateGradientTexture(gradient_data, renderer.GetContext());
223 if (gradient_texture == nullptr) {
224 return false;
225 }
226
227 FS::FragInfo frag_info;
228 frag_info.start_point = start_point_;
229 frag_info.end_point = end_point_;
230 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
231 frag_info.decal_border_color = decal_border_color_;
232 frag_info.texture_sampler_y_coord_scale =
233 gradient_texture->GetYCoordScale();
234 frag_info.alpha =
235 GetOpacityFactor() *
236 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
237 ;
238 frag_info.half_texel =
239 Vector2(0.5 / gradient_texture->GetSize().width,
240 0.5 / gradient_texture->GetSize().height);
241
242 pass.SetCommandLabel("LinearGradientFill");
243
244 SamplerDescriptor sampler_desc;
245 sampler_desc.min_filter = MinMagFilter::kLinear;
246 sampler_desc.mag_filter = MinMagFilter::kLinear;
247
248 FS::BindTextureSampler(
249 pass, std::move(gradient_texture),
250 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
251 sampler_desc));
252 FS::BindFragInfo(
253 pass, renderer.GetTransientsBuffer().EmplaceUniform(frag_info));
254 return true;
255 });
256 }
257
258 namespace {
259 Scalar CalculateInverseDotStartToEnd(Point start_point, Point end_point) {
260 Point start_to_end = end_point - start_point;
261 Scalar dot =
262 (start_to_end.x * start_to_end.x + start_to_end.y * start_to_end.y);
263 return dot == 0.0f ? 0.0f : 1.0f / dot;
264 }
265 } // namespace
266
267 bool LinearGradientContents::RenderSSBO(const ContentContext& renderer,
268 const Entity& entity,
269 RenderPass& pass) const {
270 using VS = LinearGradientSSBOFillPipeline::VertexShader;
271 using FS = LinearGradientSSBOFillPipeline::FragmentShader;
272
273 VS::FrameInfo frame_info;
274 frame_info.matrix = GetInverseEffectTransform();
275
276 PipelineBuilderCallback pipeline_callback =
277 [&renderer](ContentContextOptions options) {
278 return renderer.GetLinearGradientSSBOFillPipeline(options);
279 };
280 return ColorSourceContents::DrawGeometry<VS>(
281 renderer, entity, pass, pipeline_callback, frame_info,
282 [this, &renderer, &entity](RenderPass& pass) {
283 FS::FragInfo frag_info;
284 frag_info.start_point = start_point_;
285 frag_info.end_point = end_point_;
286 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
287 frag_info.decal_border_color = decal_border_color_;
288 frag_info.alpha =
289 GetOpacityFactor() *
290 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
291 frag_info.start_to_end = end_point_ - start_point_;
292 frag_info.inverse_dot_start_to_end =
293 CalculateInverseDotStartToEnd(start_point_, end_point_);
294
295 auto& host_buffer = renderer.GetTransientsBuffer();
296 auto colors = CreateGradientColors(colors_, stops_);
297
298 frag_info.colors_length = colors.size();
299 auto color_buffer =
300 host_buffer.Emplace(colors.data(), colors.size() * sizeof(StopData),
301 DefaultUniformAlignment());
302
303 pass.SetCommandLabel("LinearGradientSSBOFill");
304
305 FS::BindFragInfo(
306 pass, renderer.GetTransientsBuffer().EmplaceUniform(frag_info));
307 FS::BindColorData(pass, color_buffer);
308
309 return true;
310 });
311 }
312
313 bool LinearGradientContents::ApplyColorFilter(
314 const ColorFilterProc& color_filter_proc) {
315 for (Color& color : colors_) {
316 color = color_filter_proc(color);
317 }
318 decal_border_color_ = color_filter_proc(decal_border_color_);
319 return true;
320 }
321
322 } // namespace impeller
impeller::RenderPipelineHandle::FragmentShader
FragmentShader_ FragmentShader
Definition: pipeline.h:107
impeller::ColorSourceContents::PipelineBuilderCallback
std::function< std::shared_ptr< Pipeline< PipelineDescriptor > >(ContentContextOptions)> PipelineBuilderCallback
Definition: color_source_contents.h:108
impeller::ColorSourceContents::GetOpacityFactor
Scalar GetOpacityFactor() const
Get the opacity factor for this color source.
Definition: color_source_contents.cc:28
impeller::Geometry::ComputeAlphaCoverage
virtual Scalar ComputeAlphaCoverage(const Matrix &transform) const
Definition: geometry.h:124
impeller::ContentContext::GetLinearGradientFillPipeline
std::shared_ptr< Pipeline< PipelineDescriptor > > GetLinearGradientFillPipeline(ContentContextOptions opts) const
Definition: content_context.h:384
gradient_generator.h
impeller::TPoint::y
Type y
Definition: point.h:31
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::DefaultUniformAlignment
constexpr size_t DefaultUniformAlignment()
Definition: platform.h:14
geometry.h
impeller::Entity::GetTransform
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
Definition: entity.cc:47
entity.h
impeller::TRect< Scalar >::MakeXYWH
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)
Definition: rect.h:136
impeller::Color
Definition: color.h:123
impeller::LinearGradientContents::ApplyColorFilter
bool ApplyColorFilter(const ColorFilterProc &color_filter_proc) override
If possible, applies a color filter to this contents inputs on the CPU.
Definition: linear_gradient_contents.cc:313
impeller::Geometry::GetCoverage
virtual std::optional< Rect > GetCoverage(const Matrix &transform) const =0
impeller::Entity::TileMode::kDecal
@ kDecal
impeller::LinearGradientContents::Render
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
Definition: linear_gradient_contents.cc:189
impeller::Vector2
Point Vector2
Definition: point.h:331
formats.h
impeller::Color::alpha
Scalar alpha
Definition: color.h:142
impeller::LinearGradientContents::SetEndPoints
void SetEndPoints(Point start_point, Point end_point)
Definition: linear_gradient_contents.cc:22
impeller::LinearGradientContents::SetColors
void SetColors(std::vector< Color > colors)
Definition: linear_gradient_contents.cc:27
impeller::VS
SolidFillVertexShader VS
Definition: stroke_path_geometry.cc:16
impeller::PrimitiveType::kTriangle
@ kTriangle
impeller::LinearGradientContents::SetTileMode
void SetTileMode(Entity::TileMode tile_mode)
Definition: linear_gradient_contents.cc:43
impeller::Entity
Definition: entity.h:20
impeller::Point
TPoint< Scalar > Point
Definition: point.h:327
render_pass.h
impeller::LinearGradientContents::GetColors
const std::vector< Color > & GetColors() const
Definition: linear_gradient_contents.cc:35
transform
Matrix transform
Definition: gaussian_blur_filter_contents.cc:213
impeller::ContentContext::GetContext
std::shared_ptr< Context > GetContext() const
Definition: content_context.cc:550
impeller::Contents::ColorFilterProc
std::function< Color(Color)> ColorFilterProc
Definition: contents.h:35
impeller::MinMagFilter::kLinear
@ kLinear
impeller::RenderPipelineHandle::VertexShader
VertexShader_ VertexShader
Definition: pipeline.h:106
impeller::Rect
TRect< Scalar > Rect
Definition: rect.h:776
impeller::CreateGradientBuffer
GradientData CreateGradientBuffer(const std::vector< Color > &colors, const std::vector< Scalar > &stops)
Populate a vector with the interpolated color bytes for the linear gradient described by colors and s...
Definition: gradient.cc:20
impeller::Entity::TileMode
TileMode
Definition: entity.h:42
impeller::TPoint::x
Type x
Definition: point.h:30
impeller::ColorSourceContents::GetGeometry
const Geometry * GetGeometry() const
Get the geometry that this contents will use to render.
Definition: color_source_contents.cc:20
scalar.h
impeller::RenderPass
Render passes encode render commands directed as one specific render target into an underlying comman...
Definition: render_pass.h:33
content_context.h
impeller::ContentContext::GetDeviceCapabilities
const Capabilities & GetDeviceCapabilities() const
Definition: content_context.cc:554
impeller::LinearGradientContents::LinearGradientContents
LinearGradientContents()
impeller::TPoint< Scalar >
impeller::LinearGradientContents::SetStops
void SetStops(std::vector< Scalar > stops)
Definition: linear_gradient_contents.cc:31
impeller::HostBuffer::EmplaceUniform
BufferView EmplaceUniform(const UniformType &uniform)
Emplace uniform data onto the host buffer. Ensure that backend specific uniform alignment requirement...
Definition: host_buffer.h:50
impeller::LinearGradientContents::GetStops
const std::vector< Scalar > & GetStops() const
Definition: linear_gradient_contents.cc:39
impeller::ScalarNearlyEqual
constexpr bool ScalarNearlyEqual(Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
Definition: scalar.h:35
color
DlColor color
Definition: dl_golden_blur_unittests.cc:24
impeller::CreateGradientColors
std::vector< StopData > CreateGradientColors(const std::vector< Color > &colors, const std::vector< Scalar > &stops)
Populate a vector with the color and stop data for a gradient.
Definition: gradient_generator.cc:53
impeller::LinearGradientContents::IsOpaque
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
Definition: linear_gradient_contents.cc:47
impeller::CreateGradientTexture
std::shared_ptr< Texture > CreateGradientTexture(const GradientData &gradient_data, const std::shared_ptr< impeller::Context > &context)
Create a host visible texture that contains the gradient defined by the provided gradient data.
Definition: gradient_generator.cc:16
impeller::ColorSourceContents::AppliesAlphaForStrokeCoverage
bool AppliesAlphaForStrokeCoverage(const Matrix &transform) const
Whether the entity should be treated as non-opaque due to stroke geometry requiring alpha for coverag...
Definition: color_source_contents.cc:53
impeller::ContentContextOptions
Definition: content_context.h:254
impeller::Capabilities::SupportsSSBO
virtual bool SupportsSSBO() const =0
Whether the context backend supports binding Shader Storage Buffer Objects (SSBOs) to pipelines.
impeller
Definition: allocation.cc:12
impeller::LinearGradientContents::~LinearGradientContents
~LinearGradientContents() override
impeller::ContentContext
Definition: content_context.h:366
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
impeller::ColorSourceContents::GetInverseEffectTransform
const Matrix & GetInverseEffectTransform() const
Set the inverted effect transform for this color source.
Definition: color_source_contents.cc:36
impeller::ContentContext::GetTransientsBuffer
HostBuffer & GetTransientsBuffer() const
Retrieve the currnent host buffer for transient storage.
Definition: content_context.h:753
vertex_buffer_builder.h
linear_gradient_contents.h