Flutter Engine Uber Docs
Docs for the entire Flutter Engine repo.
 
Loading...
Searching...
No Matches
Namespaces | Macros
conical_gradient_contents.cc File Reference
#include "conical_gradient_contents.h"
#include "impeller/entity/contents/clip_contents.h"
#include "impeller/entity/contents/content_context.h"
#include "impeller/entity/contents/gradient_generator.h"
#include "impeller/entity/entity.h"
#include "impeller/entity/geometry/geometry.h"
#include "impeller/geometry/gradient.h"
#include "impeller/renderer/render_pass.h"

Go to the source code of this file.

Namespaces

namespace  impeller
 

Macros

#define ARRAY_LEN(a)   (sizeof(a) / sizeof(a[0]))
 
#define UNIFORM_COLORS_INFO(t)    t##GradientUniformFillConicalPipeline::FragmentShader::ColorsInfo
 
#define UNIFORM_STOP_PAIRS_INFO(t)    t##GradientUniformFillConicalPipeline::FragmentShader::StopPairsInfo
 
#define UNIFORM_COLOR_SIZE   ARRAY_LEN(UNIFORM_COLORS_INFO(Conical)::colors)
 
#define UNIFORM_STOP_SIZE    ARRAY_LEN(UNIFORM_STOP_PAIRS_INFO(Conical)::stop_pairs)
 

Macro Definition Documentation

◆ ARRAY_LEN

#define ARRAY_LEN (   a)    (sizeof(a) / sizeof(a[0]))

Definition at line 79 of file conical_gradient_contents.cc.

◆ UNIFORM_COLOR_SIZE

#define UNIFORM_COLOR_SIZE   ARRAY_LEN(UNIFORM_COLORS_INFO(Conical)::colors)

Definition at line 84 of file conical_gradient_contents.cc.

◆ UNIFORM_COLORS_INFO

#define UNIFORM_COLORS_INFO (   t)     t##GradientUniformFillConicalPipeline::FragmentShader::ColorsInfo

Definition at line 80 of file conical_gradient_contents.cc.

96 {
97 if (renderer.GetDeviceCapabilities().SupportsSSBO()) {
98 return RenderSSBO(renderer, entity, pass);
99 }
100 if (colors_.size() <= kMaxUniformGradientStops &&
101 stops_.size() <= kMaxUniformGradientStops) {
102 return RenderUniform(renderer, entity, pass);
103 }
104 return RenderTexture(renderer, entity, pass);
105}
106
107bool ConicalGradientContents::RenderSSBO(const ContentContext& renderer,
108 const Entity& entity,
109 RenderPass& pass) const {
110 using VS = ConicalGradientSSBOFillPipeline::VertexShader;
111 using FS = ConicalGradientSSBOFillPipeline::FragmentShader;
112
113 VS::FrameInfo frame_info;
114 frame_info.matrix = GetInverseEffectTransform();
115
116 ConicalKind kind = GetConicalKind(center_, radius_, focus_, focus_radius_);
117 PipelineBuilderCallback pipeline_callback =
118 [&renderer, kind](ContentContextOptions options) {
119 return renderer.GetConicalGradientSSBOFillPipeline(options, kind);
120 };
121 return ColorSourceContents::DrawGeometry<VS>(
122 renderer, entity, pass, pipeline_callback, frame_info,
123 [this, &renderer, &entity](RenderPass& pass) {
124 FS::FragInfo frag_info;
125 frag_info.center = center_;
126 frag_info.radius = radius_;
127 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
128 frag_info.decal_border_color = decal_border_color_;
129 frag_info.alpha =
130 GetOpacityFactor() *
131 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
132 if (focus_) {
133 frag_info.focus = focus_.value();
134 frag_info.focus_radius = focus_radius_;
135 } else {
136 frag_info.focus = center_;
137 frag_info.focus_radius = 0.0;
138 }
139
140 auto& data_host_buffer = renderer.GetTransientsDataBuffer();
141 auto colors = CreateGradientColors(colors_, stops_);
142
143 frag_info.colors_length = colors.size();
144 auto color_buffer = data_host_buffer.Emplace(
145 colors.data(), colors.size() * sizeof(StopData),
146 renderer.GetDeviceCapabilities()
147 .GetMinimumStorageBufferAlignment());
148
149 FS::BindFragInfo(pass, data_host_buffer.EmplaceUniform(frag_info));
150 FS::BindColorData(pass, color_buffer);
151
152 pass.SetCommandLabel("ConicalGradientSSBOFill");
153 return true;
154 });
155}
156
157bool ConicalGradientContents::RenderUniform(const ContentContext& renderer,
158 const Entity& entity,
159 RenderPass& pass) const {
160 using VS = ConicalGradientUniformFillConicalPipeline::VertexShader;
161 using FS = ConicalGradientUniformFillConicalPipeline::FragmentShader;
162
163 VS::FrameInfo frame_info;
164 frame_info.matrix = GetInverseEffectTransform();
165
166 ConicalKind kind = GetConicalKind(center_, radius_, focus_, focus_radius_);
167 PipelineBuilderCallback pipeline_callback =
168 [&renderer, kind](ContentContextOptions options) {
169 return renderer.GetConicalGradientUniformFillPipeline(options, kind);
170 };
171 return ColorSourceContents::DrawGeometry<VS>(
172 renderer, entity, pass, pipeline_callback, frame_info,
173 [this, &renderer, &entity](RenderPass& pass) {
174 FS::FragInfo frag_info;
175 FS::ColorsInfo colors_info;
176 FS::StopPairsInfo stop_pairs_info;
177
178 frag_info.center = center_;
179 if (focus_) {
180 frag_info.focus = focus_.value();
181 frag_info.focus_radius = focus_radius_;
182 } else {
183 frag_info.focus = center_;
184 frag_info.focus_radius = 0.0;
185 }
186 frag_info.radius = radius_;
187 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
188 frag_info.alpha =
189 GetOpacityFactor() *
190 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
191 frag_info.colors_length = PopulateUniformGradientColors(
192 colors_, stops_, colors_info.colors, stop_pairs_info.stop_pairs);
193 frag_info.decal_border_color = decal_border_color_;
194
195 pass.SetCommandLabel("ConicalGradientUniformFill");
196
197 auto& transients_buffer = renderer.GetTransientsDataBuffer();
198 FS::BindFragInfo(pass, transients_buffer.EmplaceUniform(frag_info));
199 FS::BindColorsInfo(pass, transients_buffer.EmplaceUniform(colors_info));
200 FS::BindStopPairsInfo(
201 pass, transients_buffer.EmplaceUniform(stop_pairs_info));
202
203 return true;
204 });
205}
206
207bool ConicalGradientContents::RenderTexture(const ContentContext& renderer,
208 const Entity& entity,
209 RenderPass& pass) const {
210 using VS = ConicalGradientFillConicalPipeline::VertexShader;
211 using FS = ConicalGradientFillConicalPipeline::FragmentShader;
212
213 auto gradient_data = CreateGradientBuffer(colors_, stops_);
214 auto gradient_texture =
215 CreateGradientTexture(gradient_data, renderer.GetContext());
216 if (gradient_texture == nullptr) {
217 return false;
218 }
219
220 VS::FrameInfo frame_info;
221 frame_info.matrix = GetInverseEffectTransform();
222
223 ConicalKind kind = GetConicalKind(center_, radius_, focus_, focus_radius_);
224 PipelineBuilderCallback pipeline_callback =
225 [&renderer, kind](ContentContextOptions options) {
226 return renderer.GetConicalGradientFillPipeline(options, kind);
227 };
228 return ColorSourceContents::DrawGeometry<VS>(
229 renderer, entity, pass, pipeline_callback, frame_info,
230 [this, &renderer, &gradient_texture, &entity](RenderPass& pass) {
231 FS::FragInfo frag_info;
232 frag_info.center = center_;
233 frag_info.radius = radius_;
234 frag_info.tile_mode = static_cast<Scalar>(tile_mode_);
235 frag_info.decal_border_color = decal_border_color_;
236 frag_info.alpha =
237 GetOpacityFactor() *
238 GetGeometry()->ComputeAlphaCoverage(entity.GetTransform());
239 frag_info.half_texel =
240 Vector2(0.5 / gradient_texture->GetSize().width,
241 0.5 / gradient_texture->GetSize().height);
242 if (focus_) {
243 frag_info.focus = focus_.value();
244 frag_info.focus_radius = focus_radius_;
245 } else {
246 frag_info.focus = center_;
247 frag_info.focus_radius = 0.0;
248 }
249
250 pass.SetCommandLabel("ConicalGradientFill");
251
252 FS::BindFragInfo(
253 pass, renderer.GetTransientsDataBuffer().EmplaceUniform(frag_info));
254 SamplerDescriptor sampler_desc;
255 sampler_desc.min_filter = MinMagFilter::kLinear;
256 sampler_desc.mag_filter = MinMagFilter::kLinear;
257 FS::BindTextureSampler(
258 pass, gradient_texture,
259 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
260 sampler_desc));
261
262 return true;
263 });
264}
265
266bool ConicalGradientContents::ApplyColorFilter(
267 const ColorFilterProc& color_filter_proc) {
268 for (Color& color : colors_) {
269 color = color_filter_proc(color);
270 }
271 decal_border_color_ = color_filter_proc(decal_border_color_);
272 return true;
273}
274
275} // namespace impeller
impeller::Vector2
Point Vector2
Definition point.h:430
impeller::Scalar
float Scalar
Definition scalar.h:19
impeller::FS
LinePipeline::FragmentShader FS
Definition line_contents.cc:12
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:11
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

◆ UNIFORM_STOP_PAIRS_INFO

#define UNIFORM_STOP_PAIRS_INFO (   t)     t##GradientUniformFillConicalPipeline::FragmentShader::StopPairsInfo

Definition at line 82 of file conical_gradient_contents.cc.

◆ UNIFORM_STOP_SIZE

#define UNIFORM_STOP_SIZE    ARRAY_LEN(UNIFORM_STOP_PAIRS_INFO(Conical)::stop_pairs)

Definition at line 85 of file conical_gradient_contents.cc.