| Flutter Impeller |

radial_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 "radial_gradient_contents.h"
6
7 #include "impeller/entity/contents/clip_contents.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/gradient.h"
13 #include "impeller/renderer/render_pass.h"
14
15 namespace impeller {
16
17 RadialGradientContents::RadialGradientContents() = default;
18
19 RadialGradientContents::~RadialGradientContents() = default;
20
21 void RadialGradientContents::SetCenterAndRadius(Point center, Scalar radius) {
22 center_ = center;
23 radius_ = radius;
24 }
25
26 void RadialGradientContents::SetTileMode(Entity::TileMode tile_mode) {
27 tile_mode_ = tile_mode;
28 }
29
30 void RadialGradientContents::SetColors(std::vector<Color> colors) {
31 colors_ = std::move(colors);
32 }
33
34 void RadialGradientContents::SetStops(std::vector<Scalar> stops) {
35 stops_ = std::move(stops);
36 }
37
38 const std::vector<Color>& RadialGradientContents::GetColors() const {
39 return colors_;
40 }
41
42 const std::vector<Scalar>& RadialGradientContents::GetStops() const {
43 return stops_;
44 }
45
46 bool RadialGradientContents::IsOpaque(const Matrix& transform) const {
47 if (GetOpacityFactor() < 1 || tile_mode_ == Entity::TileMode::kDecal) {
48 return false;
49 }
50 for (auto color : colors_) {
51 if (!color.IsOpaque()) {
52 return false;
53 }
54 }
55 return !AppliesAlphaForStrokeCoverage(transform);
56 }
57
58 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
59 #define UNIFORM_FRAG_INFO(t) \
60 t##GradientUniformFillPipeline::FragmentShader::FragInfo
61 #define UNIFORM_COLOR_SIZE ARRAY_LEN(UNIFORM_FRAG_INFO(Radial)::colors)
62 #define UNIFORM_STOP_SIZE ARRAY_LEN(UNIFORM_FRAG_INFO(Radial)::stop_pairs)
63 static_assert(UNIFORM_COLOR_SIZE == kMaxUniformGradientStops);
64 static_assert(UNIFORM_STOP_SIZE == kMaxUniformGradientStops / 2);
65
66 bool RadialGradientContents::Render(const ContentContext& renderer,
67 const Entity& entity,
68 RenderPass& pass) const {
69 if (renderer.GetDeviceCapabilities().SupportsSSBO()) {
70 return RenderSSBO(renderer, entity, pass);
71 }
72 if (colors_.size() <= kMaxUniformGradientStops &&
73 stops_.size() <= kMaxUniformGradientStops) {
74 return RenderUniform(renderer, entity, pass);
75 }
76 return RenderTexture(renderer, entity, pass);
77 }
78
79 bool RadialGradientContents::RenderSSBO(const ContentContext& renderer,
80 const Entity& entity,
81 RenderPass& pass) const {
82 using VS = RadialGradientSSBOFillPipeline::VertexShader;
83 using FS = RadialGradientSSBOFillPipeline::FragmentShader;
84
85 VS::FrameInfo frame_info;
86 frame_info.matrix = GetInverseEffectTransform();
87
88 PipelineBuilderCallback pipeline_callback =
89 [&renderer](ContentContextOptions options) {
90 return renderer.GetRadialGradientSSBOFillPipeline(options);
91 };
92 return ColorSourceContents::DrawGeometry<VS>(
93 renderer, entity, pass, pipeline_callback, frame_info,
94 [this, &renderer, &entity](RenderPass& pass) {
95 FS::FragInfo frag_info;
96 frag_info.center = center_;
97 frag_info.radius = radius_;
98 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
99 frag_info.decal_border_color = decal_border_color_;
100 frag_info.alpha =
101 GetOpacityFactor() *
102 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
103
104 auto& data_host_buffer = renderer.GetTransientsDataBuffer();
105 auto colors = CreateGradientColors(colors_, stops_);
106
107 frag_info.colors_length = colors.size();
108 auto color_buffer = data_host_buffer.Emplace(
109 colors.data(), colors.size() * sizeof(StopData),
110 renderer.GetDeviceCapabilities()
111 .GetMinimumStorageBufferAlignment());
112
113 pass.SetCommandLabel("RadialGradientSSBOFill");
114 FS::BindFragInfo(pass, data_host_buffer.EmplaceUniform(frag_info));
115 FS::BindColorData(pass, color_buffer);
116
117 return true;
118 });
119 }
120
121 bool RadialGradientContents::RenderUniform(const ContentContext& renderer,
122 const Entity& entity,
123 RenderPass& pass) const {
124 using VS = RadialGradientUniformFillPipeline::VertexShader;
125 using FS = RadialGradientUniformFillPipeline::FragmentShader;
126
127 VS::FrameInfo frame_info;
128 frame_info.matrix = GetInverseEffectTransform();
129
130 PipelineBuilderCallback pipeline_callback =
131 [&renderer](ContentContextOptions options) {
132 return renderer.GetRadialGradientUniformFillPipeline(options);
133 };
134 return ColorSourceContents::DrawGeometry<VS>(
135 renderer, entity, pass, pipeline_callback, frame_info,
136 [this, &renderer, &entity](RenderPass& pass) {
137 FS::FragInfo frag_info;
138 frag_info.center = center_;
139 frag_info.radius = radius_;
140 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
141 frag_info.alpha =
142 GetOpacityFactor() *
143 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
144 frag_info.colors_length = PopulateUniformGradientColors(
145 colors_, stops_, frag_info.colors, frag_info.stop_pairs);
146 frag_info.decal_border_color = decal_border_color_;
147
148 pass.SetCommandLabel("RadialGradientUniformFill");
149
150 FS::BindFragInfo(
151 pass, renderer.GetTransientsDataBuffer().EmplaceUniform(frag_info));
152
153 return true;
154 });
155 }
156
157 bool RadialGradientContents::RenderTexture(const ContentContext& renderer,
158 const Entity& entity,
159 RenderPass& pass) const {
160 using VS = RadialGradientFillPipeline::VertexShader;
161 using FS = RadialGradientFillPipeline::FragmentShader;
162
163 auto gradient_data = CreateGradientBuffer(colors_, stops_);
164 auto gradient_texture =
165 CreateGradientTexture(gradient_data, renderer.GetContext());
166 if (gradient_texture == nullptr) {
167 return false;
168 }
169
170 VS::FrameInfo frame_info;
171 frame_info.matrix = GetInverseEffectTransform();
172
173 PipelineBuilderCallback pipeline_callback =
174 [&renderer](ContentContextOptions options) {
175 return renderer.GetRadialGradientFillPipeline(options);
176 };
177 return ColorSourceContents::DrawGeometry<VS>(
178 renderer, entity, pass, pipeline_callback, frame_info,
179 [this, &renderer, &gradient_texture, &entity](RenderPass& pass) {
180 FS::FragInfo frag_info;
181 frag_info.center = center_;
182 frag_info.radius = radius_;
183 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
184 frag_info.decal_border_color = decal_border_color_;
185 frag_info.texture_sampler_y_coord_scale =
186 gradient_texture->GetYCoordScale();
187 frag_info.alpha =
188 GetOpacityFactor() *
189 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
190 frag_info.half_texel =
191 Vector2(0.5 / gradient_texture->GetSize().width,
192 0.5 / gradient_texture->GetSize().height);
193
194 SamplerDescriptor sampler_desc;
195 sampler_desc.min_filter = MinMagFilter::kLinear;
196 sampler_desc.mag_filter = MinMagFilter::kLinear;
197
198 pass.SetCommandLabel("RadialGradientFill");
199
200 FS::BindFragInfo(
201 pass, renderer.GetTransientsDataBuffer().EmplaceUniform(frag_info));
202 FS::BindTextureSampler(
203 pass, gradient_texture,
204 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
205 sampler_desc));
206
207 return true;
208 });
209 }
210
211 bool RadialGradientContents::ApplyColorFilter(
212 const ColorFilterProc& color_filter_proc) {
213 for (Color& color : colors_) {
214 color = color_filter_proc(color);
215 }
216 decal_border_color_ = color_filter_proc(decal_border_color_);
217 return true;
218 }
219
220 } // namespace impeller
impeller::Capabilities::GetMinimumStorageBufferAlignment
virtual size_t GetMinimumStorageBufferAlignment() const
The minimum alignment of storage buffer value offsets in bytes.
Definition: capabilities.cc:14
impeller::Capabilities::SupportsSSBO
virtual bool SupportsSSBO() const =0
Whether the context backend supports binding Shader Storage Buffer Objects (SSBOs) to pipelines.
impeller::ColorSourceContents::GetGeometry
const Geometry * GetGeometry() const
Get the geometry that this contents will use to render.
Definition: color_source_contents.cc:20
impeller::ColorSourceContents::GetOpacityFactor
Scalar GetOpacityFactor() const
Get the opacity factor for this color source.
Definition: color_source_contents.cc:28
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::ColorSourceContents::GetInverseEffectTransform
const Matrix & GetInverseEffectTransform() const
Set the inverted effect transform for this color source.
Definition: color_source_contents.cc:36
impeller::ColorSourceContents::PipelineBuilderCallback
std::function< PipelineRef(ContentContextOptions)> PipelineBuilderCallback
Definition: color_source_contents.h:42
impeller::ContentContext
Definition: content_context.h:122
impeller::ContentContext::GetDeviceCapabilities
const Capabilities & GetDeviceCapabilities() const
Definition: content_context.cc:973
impeller::ContentContext::GetRadialGradientSSBOFillPipeline
PipelineRef GetRadialGradientSSBOFillPipeline(ContentContextOptions opts) const
Definition: content_context.cc:1058
impeller::ContentContext::GetTransientsDataBuffer
HostBuffer & GetTransientsDataBuffer() const
Retrieve the current host buffer for transient storage of other non-index data.
Definition: content_context.h:299
impeller::Contents::ColorFilterProc
std::function< Color(Color)> ColorFilterProc
Definition: contents.h:35
impeller::Entity
Definition: entity.h:26
impeller::Entity::TileMode
TileMode
Definition: entity.h:48
impeller::Entity::TileMode::kDecal
@ kDecal
impeller::Entity::GetTransform
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
Definition: entity.cc:46
impeller::Geometry::ComputeAlphaCoverage
virtual Scalar ComputeAlphaCoverage(const Matrix &transform) const
Definition: geometry.h:125
impeller::RadialGradientContents::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: radial_gradient_contents.cc:46
impeller::RadialGradientContents::SetTileMode
void SetTileMode(Entity::TileMode tile_mode)
Definition: radial_gradient_contents.cc:26
impeller::RadialGradientContents::~RadialGradientContents
~RadialGradientContents() override
impeller::RadialGradientContents::Render
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
Definition: radial_gradient_contents.cc:66
impeller::RadialGradientContents::SetCenterAndRadius
void SetCenterAndRadius(Point center, Scalar radius)
Definition: radial_gradient_contents.cc:21
impeller::RadialGradientContents::SetStops
void SetStops(std::vector< Scalar > stops)
Definition: radial_gradient_contents.cc:34
impeller::RadialGradientContents::ApplyColorFilter
bool ApplyColorFilter(const ColorFilterProc &color_filter_proc) override
If possible, applies a color filter to this contents inputs on the CPU.
Definition: radial_gradient_contents.cc:211
impeller::RadialGradientContents::SetColors
void SetColors(std::vector< Color > colors)
Definition: radial_gradient_contents.cc:30
impeller::RadialGradientContents::GetStops
const std::vector< Scalar > & GetStops() const
Definition: radial_gradient_contents.cc:42
impeller::RadialGradientContents::RadialGradientContents
RadialGradientContents()
impeller::RadialGradientContents::GetColors
const std::vector< Color > & GetColors() const
Definition: radial_gradient_contents.cc:38
impeller::RenderPass
Render passes encode render commands directed as one specific render target into an underlying comman...
Definition: render_pass.h:30
impeller::RenderPipelineHandle::VertexShader
VertexShader_ VertexShader
Definition: pipeline.h:163
impeller::RenderPipelineHandle::FragmentShader
FragmentShader_ FragmentShader
Definition: pipeline.h:164
clip_contents.h
content_context.h
entity.h
transform
Matrix transform
Definition: gaussian_blur_filter_contents.cc:312
geometry.h
gradient.h
gradient_generator.h
impeller
Definition: allocation.cc:12
impeller::Vector2
Point Vector2
Definition: point.h:429
impeller::Scalar
float Scalar
Definition: scalar.h:19
impeller::FS
LinePipeline::FragmentShader FS
Definition: line_contents.cc:14
impeller::PopulateUniformGradientColors
int PopulateUniformGradientColors(const std::vector< Color > &colors, const std::vector< Scalar > &stops, Vector4 frag_info_colors[kMaxUniformGradientStops], Vector4 frag_info_stop_pairs[kMaxUniformGradientStops/2])
Populate 2 arrays with the colors and stop data for a gradient.
Definition: gradient_generator.cc:51
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:34
impeller::VS
LinePipeline::VertexShader VS
Definition: line_contents.cc:13
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:17
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::MinMagFilter::kLinear
@ kLinear
impeller::kMaxUniformGradientStops
static constexpr uint32_t kMaxUniformGradientStops
Definition: gradient_generator.h:47
UNIFORM_STOP_SIZE
#define UNIFORM_STOP_SIZE
Definition: radial_gradient_contents.cc:62
UNIFORM_COLOR_SIZE
#define UNIFORM_COLOR_SIZE
Definition: radial_gradient_contents.cc:61
radial_gradient_contents.h
render_pass.h
impeller::Color
Definition: color.h:124
impeller::Color::alpha
Scalar alpha
Definition: color.h:143
impeller::ContentContextOptions
Definition: content_context.h:40
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
impeller::TPoint< Scalar >