23 start_point_ = start_point;
24 end_point_ = end_point;
28 colors_ = std::move(colors);
32 stops_ = std::move(stops);
44 tile_mode_ = tile_mode;
51 for (
auto color : colors_) {
52 if (!color.IsOpaque()) {
59 bool LinearGradientContents::CanApplyFastGradient()
const {
64 if (!maybe_rect.has_value()) {
67 Rect rect = maybe_rect.value();
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_;
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_;
104 bool LinearGradientContents::FastLinearGradient(
const ContentContext& renderer,
105 const Entity& entity,
106 RenderPass& pass)
const {
111 bool force_stencil = !geometry->IsAxisAlignedRect();
113 auto geom_callback = [&](
const ContentContext& renderer,
const Entity& entity,
115 const Geometry* geometry) -> GeometryResult {
120 std::optional<Rect> maybe_rect = geometry->GetCoverage(Matrix());
121 if (!maybe_rect.has_value()) {
124 Rect rect = maybe_rect.value();
125 bool horizontal_axis = start_point_.
y == end_point_.
y;
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++) {
135 Point current = (1.0 - t) * start_point_ + t * end_point_;
136 Rect section = horizontal_axis
138 current.x - prev.x, rect.GetHeight())
140 :
Rect::MakeXYWH(rect.GetX(), prev.y, rect.GetWidth(),
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]},
156 return GeometryResult{
159 vtx_builder.CreateVertexBuffer(renderer.GetTransientsBuffer()),
160 .transform = entity.GetShaderTransform(pass),
164 pass.SetLabel(
"LinearGradient");
166 VS::FrameInfo frame_info;
169 [&renderer](ContentContextOptions options) {
170 return renderer.GetFastGradientPipeline(options);
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();
177 FS::FragInfo frag_info;
182 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
186 force_stencil, geom_callback);
189 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
190 #define UNIFORM_FRAG_INFO(t) \
191 t##GradientUniformFillPipeline::FragmentShader::FragInfo
192 #define UNIFORM_COLOR_SIZE ARRAY_LEN(UNIFORM_FRAG_INFO(Linear)::colors)
193 #define UNIFORM_STOP_SIZE ARRAY_LEN(UNIFORM_FRAG_INFO(Linear)::stop_pairs)
203 if (CanApplyFastGradient()) {
204 return FastLinearGradient(renderer, entity, pass);
207 return RenderSSBO(renderer, entity, pass);
211 return RenderUniform(renderer, entity, pass);
213 return RenderTexture(renderer, entity, pass);
216 bool LinearGradientContents::RenderTexture(
const ContentContext& renderer,
222 VS::FrameInfo frame_info;
229 return ColorSourceContents::DrawGeometry<VS>(
230 renderer, entity, pass, pipeline_callback, frame_info,
231 [
this, &renderer, &entity](RenderPass& pass) {
233 auto gradient_texture =
235 if (gradient_texture ==
nullptr) {
239 FS::FragInfo frag_info;
240 frag_info.start_point = start_point_;
241 frag_info.end_point = end_point_;
242 frag_info.tile_mode =
static_cast<Scalar>(tile_mode_);
243 frag_info.decal_border_color = decal_border_color_;
244 frag_info.texture_sampler_y_coord_scale =
245 gradient_texture->GetYCoordScale();
250 frag_info.half_texel =
251 Vector2(0.5 / gradient_texture->GetSize().width,
252 0.5 / gradient_texture->GetSize().height);
254 pass.SetCommandLabel(
"LinearGradientFill");
256 SamplerDescriptor sampler_desc;
260 FS::BindTextureSampler(
261 pass, std::move(gradient_texture),
262 renderer.
GetContext()->GetSamplerLibrary()->GetSampler(
272 Point start_to_end = end_point - start_point;
274 (start_to_end.x * start_to_end.x + start_to_end.y * start_to_end.y);
275 return dot == 0.0f ? 0.0f : 1.0f / dot;
279 bool LinearGradientContents::RenderSSBO(
const ContentContext& renderer,
280 const Entity& entity,
281 RenderPass& pass)
const {
285 VS::FrameInfo frame_info;
289 [&renderer](ContentContextOptions options) {
290 return renderer.GetLinearGradientSSBOFillPipeline(options);
292 return ColorSourceContents::DrawGeometry<VS>(
293 renderer, entity, pass, pipeline_callback, frame_info,
294 [
this, &renderer, &entity](RenderPass& pass) {
295 FS::FragInfo frag_info;
296 frag_info.start_point = start_point_;
297 frag_info.end_point = end_point_;
298 frag_info.tile_mode =
static_cast<Scalar>(tile_mode_);
299 frag_info.decal_border_color = decal_border_color_;
303 frag_info.start_to_end = end_point_ - start_point_;
304 frag_info.inverse_dot_start_to_end =
305 CalculateInverseDotStartToEnd(start_point_, end_point_);
307 auto& host_buffer = renderer.GetTransientsBuffer();
310 frag_info.colors_length = colors.size();
312 host_buffer.Emplace(colors.data(), colors.size() *
sizeof(StopData),
313 host_buffer.GetMinimumUniformAlignment());
315 pass.SetCommandLabel(
"LinearGradientSSBOFill");
318 pass, renderer.GetTransientsBuffer().EmplaceUniform(frag_info));
319 FS::BindColorData(pass, color_buffer);
325 bool LinearGradientContents::RenderUniform(
const ContentContext& renderer,
326 const Entity& entity,
327 RenderPass& pass)
const {
331 VS::FrameInfo frame_info;
335 [&renderer](ContentContextOptions options) {
336 return renderer.GetLinearGradientUniformFillPipeline(options);
338 return ColorSourceContents::DrawGeometry<VS>(
339 renderer, entity, pass, pipeline_callback, frame_info,
340 [
this, &renderer, &entity](RenderPass& pass) {
341 FS::FragInfo frag_info;
342 frag_info.start_point = start_point_;
343 frag_info.start_to_end = end_point_ - start_point_;
347 frag_info.tile_mode =
static_cast<Scalar>(tile_mode_);
349 colors_, stops_, frag_info.colors, frag_info.stop_pairs);
350 frag_info.inverse_dot_start_to_end =
351 CalculateInverseDotStartToEnd(start_point_, end_point_);
352 frag_info.decal_border_color = decal_border_color_;
354 pass.SetCommandLabel(
"LinearGradientUniformFill");
357 pass, renderer.GetTransientsBuffer().EmplaceUniform(frag_info));
365 for (
Color& color : colors_) {
366 color = color_filter_proc(color);
368 decal_border_color_ = color_filter_proc(decal_border_color_);
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.
PipelineRef GetLinearGradientFillPipeline(ContentContextOptions opts) const
const Capabilities & GetDeviceCapabilities() const
std::shared_ptr< Context > GetContext() const
std::function< Color(Color)> ColorFilterProc
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
virtual Scalar ComputeAlphaCoverage(const Matrix &transform) const
virtual std::optional< Rect > GetCoverage(const Matrix &transform) const =0
BufferView EmplaceUniform(const UniformType &uniform)
Emplace uniform data onto the host buffer. Ensure that backend specific uniform alignment requirement...
~LinearGradientContents() override
const std::vector< Color > & GetColors() const
void SetTileMode(Entity::TileMode tile_mode)
const std::vector< Scalar > & GetStops() const
void SetColors(std::vector< Color > colors)
bool ApplyColorFilter(const ColorFilterProc &color_filter_proc) override
If possible, applies a color filter to this contents inputs on the CPU.
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
void SetEndPoints(Point start_point, Point end_point)
void SetStops(std::vector< Scalar > stops)
bool IsOpaque(const Matrix &transform) const override
Whether this Contents only emits opaque source colors from the fragment stage. This value does not ac...
Render passes encode render commands directed as one specific render target into an underlying comman...
VertexShader_ VertexShader
FragmentShader_ FragmentShader
#define UNIFORM_STOP_SIZE
#define UNIFORM_COLOR_SIZE
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...
constexpr bool ScalarNearlyEqual(Scalar x, Scalar y, Scalar tolerance=kEhCloseEnough)
static constexpr uint32_t kMaxUniformGradientStops
A 4x4 matrix using column-major storage.
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)