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 
6 
10 #include "impeller/entity/entity.h"
14 
15 namespace impeller {
16 
18 
20 
22  center_ = center;
23  radius_ = radius;
24 }
25 
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 
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  }
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)
64 static_assert(UNIFORM_STOP_SIZE == kMaxUniformGradientStops / 2);
65 
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 {
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() *
103 
104  auto& host_buffer = renderer.GetTransientsBuffer();
105  auto colors = CreateGradientColors(colors_, stops_);
106 
107  frag_info.colors_length = colors.size();
108  auto color_buffer =
109  host_buffer.Emplace(colors.data(), colors.size() * sizeof(StopData),
110  host_buffer.GetMinimumUniformAlignment());
111 
112  pass.SetCommandLabel("RadialGradientSSBOFill");
113  FS::BindFragInfo(
114  pass, renderer.GetTransientsBuffer().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 {
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.GetTransientsBuffer().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 {
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.GetTransientsBuffer().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 
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
virtual bool SupportsSSBO() const =0
Whether the context backend supports binding Shader Storage Buffer Objects (SSBOs) to pipelines.
const Geometry * GetGeometry() const
Get the geometry that this contents will use to render.
Scalar GetOpacityFactor() const
Get the opacity factor for this color source.
bool AppliesAlphaForStrokeCoverage(const Matrix &transform) const
Whether the entity should be treated as non-opaque due to stroke geometry requiring alpha for coverag...
const Matrix & GetInverseEffectTransform() const
Set the inverted effect transform for this color source.
std::function< PipelineRef(ContentContextOptions)> PipelineBuilderCallback
HostBuffer & GetTransientsBuffer() const
Retrieve the currnent host buffer for transient storage.
const Capabilities & GetDeviceCapabilities() const
PipelineRef GetRadialGradientSSBOFillPipeline(ContentContextOptions opts) const
std::function< Color(Color)> ColorFilterProc
Definition: contents.h:35
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
Definition: entity.cc:44
virtual Scalar ComputeAlphaCoverage(const Matrix &transform) const
Definition: geometry.h:125
BufferView EmplaceUniform(const UniformType &uniform)
Emplace uniform data onto the host buffer. Ensure that backend specific uniform alignment requirement...
Definition: host_buffer.h:47
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
void SetTileMode(Entity::TileMode tile_mode)
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
void SetCenterAndRadius(Point center, Scalar radius)
void SetStops(std::vector< Scalar > stops)
bool ApplyColorFilter(const ColorFilterProc &color_filter_proc) override
If possible, applies a color filter to this contents inputs on the CPU.
void SetColors(std::vector< Color > colors)
const std::vector< Scalar > & GetStops() const
const std::vector< Color > & GetColors() const
Render passes encode render commands directed as one specific render target into an underlying comman...
Definition: render_pass.h:30
FragmentShader_ FragmentShader
Definition: pipeline.h:164
Point Vector2
Definition: point.h:331
float Scalar
Definition: scalar.h:19
LinePipeline::FragmentShader FS
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.
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.
LinePipeline::VertexShader VS
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.
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
static constexpr uint32_t kMaxUniformGradientStops
#define UNIFORM_STOP_SIZE
#define UNIFORM_COLOR_SIZE
Scalar alpha
Definition: color.h:143
A 4x4 matrix using column-major storage.
Definition: matrix.h:37