| Flutter Impeller |

border_mask_blur_filter_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 "impeller/entity/contents/filters/border_mask_blur_filter_contents.h"
6 #include "impeller/entity/contents/content_context.h"
7
8 #include "impeller/entity/contents/anonymous_contents.h"
9 #include "impeller/entity/contents/contents.h"
10 #include "impeller/renderer/render_pass.h"
11 #include "impeller/renderer/vertex_buffer_builder.h"
12
13 namespace impeller {
14
15 BorderMaskBlurFilterContents::BorderMaskBlurFilterContents() = default;
16
17 BorderMaskBlurFilterContents::~BorderMaskBlurFilterContents() = default;
18
19 void BorderMaskBlurFilterContents::SetSigma(Sigma sigma_x, Sigma sigma_y) {
20 sigma_x_ = sigma_x;
21 sigma_y_ = sigma_y;
22 }
23
24 void BorderMaskBlurFilterContents::SetBlurStyle(BlurStyle blur_style) {
25 blur_style_ = blur_style;
26
27 switch (blur_style) {
28 case FilterContents::BlurStyle::kNormal:
29 src_color_factor_ = false;
30 inner_blur_factor_ = true;
31 outer_blur_factor_ = true;
32 break;
33 case FilterContents::BlurStyle::kSolid:
34 src_color_factor_ = true;
35 inner_blur_factor_ = false;
36 outer_blur_factor_ = true;
37 break;
38 case FilterContents::BlurStyle::kOuter:
39 src_color_factor_ = false;
40 inner_blur_factor_ = false;
41 outer_blur_factor_ = true;
42 break;
43 case FilterContents::BlurStyle::kInner:
44 src_color_factor_ = false;
45 inner_blur_factor_ = true;
46 outer_blur_factor_ = false;
47 break;
48 }
49 }
50
51 std::optional<Entity> BorderMaskBlurFilterContents::RenderFilter(
52 const FilterInput::Vector& inputs,
53 const ContentContext& renderer,
54 const Entity& entity,
55 const Matrix& effect_transform,
56 const Rect& coverage,
57 const std::optional<Rect>& coverage_hint) const {
58 using VS = BorderMaskBlurPipeline::VertexShader;
59 using FS = BorderMaskBlurPipeline::FragmentShader;
60
61 //----------------------------------------------------------------------------
62 /// Handle inputs.
63 ///
64
65 if (inputs.empty()) {
66 return std::nullopt;
67 }
68
69 auto input_snapshot =
70 inputs[0]->GetSnapshot("BorderMaskBlur", renderer, entity);
71 if (!input_snapshot.has_value()) {
72 return std::nullopt;
73 }
74
75 auto maybe_input_uvs = input_snapshot->GetCoverageUVs(coverage);
76 if (!maybe_input_uvs.has_value()) {
77 return std::nullopt;
78 }
79 auto input_uvs = maybe_input_uvs.value();
80
81 //----------------------------------------------------------------------------
82 /// Create AnonymousContents for rendering.
83 ///
84
85 auto sigma = effect_transform * Vector2(sigma_x_.sigma, sigma_y_.sigma);
86 RenderProc render_proc = [coverage, input_snapshot, input_uvs = input_uvs,
87 src_color_factor = src_color_factor_,
88 inner_blur_factor = inner_blur_factor_,
89 outer_blur_factor = outer_blur_factor_, sigma](
90 const ContentContext& renderer,
91 const Entity& entity, RenderPass& pass) -> bool {
92 auto& host_buffer = renderer.GetTransientsBuffer();
93
94 auto origin = coverage.GetOrigin();
95 auto size = coverage.GetSize();
96 std::array<VS::PerVertexData, 4> vertices = {
97 VS::PerVertexData{origin, input_uvs[0]},
98 VS::PerVertexData{{origin.x + size.width, origin.y}, input_uvs[1]},
99 VS::PerVertexData{{origin.x, origin.y + size.height}, input_uvs[2]},
100 VS::PerVertexData{{origin.x + size.width, origin.y + size.height},
101 input_uvs[3]},
102 };
103
104 auto options = OptionsFromPassAndEntity(pass, entity);
105 options.primitive_type = PrimitiveType::kTriangleStrip;
106
107 VS::FrameInfo frame_info;
108 frame_info.mvp = entity.GetShaderTransform(pass);
109 frame_info.texture_sampler_y_coord_scale =
110 input_snapshot->texture->GetYCoordScale();
111
112 FS::FragInfo frag_info;
113 frag_info.sigma_uv = sigma.Abs() / input_snapshot->texture->GetSize();
114 frag_info.src_factor = src_color_factor;
115 frag_info.inner_blur_factor = inner_blur_factor;
116 frag_info.outer_blur_factor = outer_blur_factor;
117
118 pass.SetCommandLabel("Border Mask Blur Filter");
119 pass.SetPipeline(renderer.GetBorderMaskBlurPipeline(options));
120 pass.SetVertexBuffer(CreateVertexBuffer(vertices, host_buffer));
121
122 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
123 VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
124
125 const std::unique_ptr<const Sampler>& sampler =
126 renderer.GetContext()->GetSamplerLibrary()->GetSampler({});
127 FS::BindTextureSampler(pass, input_snapshot->texture, sampler);
128
129 return pass.Draw().ok();
130 };
131
132 CoverageProc coverage_proc =
133 [coverage](const Entity& entity) -> std::optional<Rect> {
134 return coverage.TransformBounds(entity.GetTransform());
135 };
136
137 auto contents = AnonymousContents::Make(render_proc, coverage_proc);
138
139 Entity sub_entity;
140 sub_entity.SetContents(std::move(contents));
141 sub_entity.SetBlendMode(entity.GetBlendMode());
142 return sub_entity;
143 }
144
145 std::optional<Rect> BorderMaskBlurFilterContents::GetFilterCoverage(
146 const FilterInput::Vector& inputs,
147 const Entity& entity,
148 const Matrix& effect_transform) const {
149 if (inputs.empty()) {
150 return std::nullopt;
151 }
152
153 auto coverage = inputs[0]->GetCoverage(entity);
154 if (!coverage.has_value()) {
155 return std::nullopt;
156 }
157 auto transform = inputs[0]->GetTransform(entity) * effect_transform;
158 auto transformed_blur_vector =
159 transform.TransformDirection(Vector2(Radius{sigma_x_}.radius, 0)).Abs() +
160 transform.TransformDirection(Vector2(0, Radius{sigma_y_}.radius)).Abs();
161 return coverage->Expand(transformed_blur_vector);
162 }
163
164 std::optional<Rect> BorderMaskBlurFilterContents::GetFilterSourceCoverage(
165 const Matrix& effect_transform,
166 const Rect& output_limit) const {
167 auto transformed_blur_vector =
168 effect_transform.TransformDirection(Vector2(Radius{sigma_x_}.radius, 0))
169 .Abs() +
170 effect_transform.TransformDirection(Vector2(0, Radius{sigma_y_}.radius))
171 .Abs();
172 return output_limit.Expand(transformed_blur_vector);
173 }
174
175 } // namespace impeller
impeller::Sigma::sigma
Scalar sigma
Definition: sigma.h:33
impeller::RenderPipelineHandle::FragmentShader
FragmentShader_ FragmentShader
Definition: pipeline.h:107
contents.h
impeller::BorderMaskBlurFilterContents::SetSigma
void SetSigma(Sigma sigma_x, Sigma sigma_y)
Definition: border_mask_blur_filter_contents.cc:19
impeller::FilterContents::BlurStyle
BlurStyle
Definition: filter_contents.h:26
impeller::BorderMaskBlurFilterContents::BorderMaskBlurFilterContents
BorderMaskBlurFilterContents()
impeller::TRect::TransformBounds
constexpr TRect TransformBounds(const Matrix &transform) const
Creates a new bounding box that contains this transformed rectangle.
Definition: rect.h:466
border_mask_blur_filter_contents.h
impeller::Vector2
Point Vector2
Definition: point.h:331
impeller::BorderMaskBlurFilterContents::SetBlurStyle
void SetBlurStyle(BlurStyle blur_style)
Definition: border_mask_blur_filter_contents.cc:24
impeller::BorderMaskBlurFilterContents::~BorderMaskBlurFilterContents
~BorderMaskBlurFilterContents() override
impeller::FilterContents::BlurStyle::kNormal
@ kNormal
Blurred inside and outside.
impeller::TRect::GetOrigin
constexpr TPoint< Type > GetOrigin() const
Returns the upper left corner of the rectangle as specified by the left/top or x/y values when it was...
Definition: rect.h:314
impeller::VS
SolidFillVertexShader VS
Definition: stroke_path_geometry.cc:16
impeller::Entity
Definition: entity.h:20
impeller::OptionsFromPassAndEntity
ContentContextOptions OptionsFromPassAndEntity(const RenderPass &pass, const Entity &entity)
Definition: contents.cc:34
impeller::PrimitiveType::kTriangleStrip
@ kTriangleStrip
render_pass.h
impeller::Radius
For convolution filters, the "radius" is the size of the convolution kernel to use on the local space...
Definition: sigma.h:48
impeller::FilterContents::BlurStyle::kSolid
@ kSolid
Solid inside, blurred outside.
transform
Matrix transform
Definition: gaussian_blur_filter_contents.cc:213
impeller::CreateVertexBuffer
VertexBuffer CreateVertexBuffer(std::array< VertexType, size > input, HostBuffer &host_buffer)
Create an index-less vertex buffer from a fixed size array.
Definition: vertex_buffer_builder.h:24
impeller::RenderPipelineHandle::VertexShader
VertexShader_ VertexShader
Definition: pipeline.h:106
impeller::Sigma
In filters that use Gaussian distributions, "sigma" is a size of one standard deviation in terms of t...
Definition: sigma.h:32
impeller::FilterContents::BlurStyle::kInner
@ kInner
Blurred inside, nothing outside.
anonymous_contents.h
impeller::Matrix::TransformDirection
constexpr Vector4 TransformDirection(const Vector4 &v) const
Definition: matrix.h:497
content_context.h
impeller::FilterContents::BlurStyle::kOuter
@ kOuter
Nothing inside, blurred outside.
impeller::Contents::RenderProc
std::function< bool(const ContentContext &renderer, const Entity &entity, RenderPass &pass)> RenderProc
Definition: contents.h:57
impeller::TRect::GetSize
constexpr TSize< Type > GetSize() const
Returns the size of the rectangle which may be negative in either width or height and may have been c...
Definition: rect.h:321
impeller::Contents::CoverageProc
std::function< std::optional< Rect >(const Entity &entity)> CoverageProc
Definition: contents.h:58
impeller::FilterInput::Vector
std::vector< FilterInput::Ref > Vector
Definition: filter_input.h:33
impeller::BorderMaskBlurFilterContents::GetFilterCoverage
std::optional< Rect > GetFilterCoverage(const FilterInput::Vector &inputs, const Entity &entity, const Matrix &effect_transform) const override
Internal utility method for |GetLocalCoverage| that computes the output coverage of this filter acros...
Definition: border_mask_blur_filter_contents.cc:145
impeller
Definition: allocation.cc:12
impeller::BorderMaskBlurFilterContents::GetFilterSourceCoverage
std::optional< Rect > GetFilterSourceCoverage(const Matrix &effect_transform, const Rect &output_limit) const override
Internal utility method for |GetSourceCoverage| that computes the inverse effect of this transform on...
Definition: border_mask_blur_filter_contents.cc:164
impeller::ContentContext
Definition: content_context.h:366
impeller::TRect
Definition: rect.h:122
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
impeller::AnonymousContents::Make
static std::shared_ptr< Contents > Make(RenderProc render_proc, CoverageProc coverage_proc)
Definition: anonymous_contents.cc:11
impeller::TRect::Expand
constexpr TRect< T > Expand(T left, T top, T right, T bottom) const
Returns a rectangle with expanded edges. Negative expansion results in shrinking.
Definition: rect.h:612
vertex_buffer_builder.h