Flutter Impeller
morphology_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 
6 
7 #include <cmath>
8 
14 
15 namespace impeller {
16 
18  default;
19 
21  default;
22 
24  radius_ = radius;
25 }
26 
28  direction_ = direction.Normalize();
29  if (direction_.IsZero()) {
30  direction_ = Vector2(0, 1);
31  }
32 }
33 
35  morph_type_ = morph_type;
36 }
37 
38 std::optional<Entity> DirectionalMorphologyFilterContents::RenderFilter(
39  const FilterInput::Vector& inputs,
40  const ContentContext& renderer,
41  const Entity& entity,
42  const Matrix& effect_transform,
43  const Rect& coverage,
44  const std::optional<Rect>& coverage_hint) const {
47 
48  //----------------------------------------------------------------------------
49  /// Handle inputs.
50  ///
51 
52  if (inputs.empty()) {
53  return std::nullopt;
54  }
55 
56  auto input_snapshot = inputs[0]->GetSnapshot("Morphology", renderer, entity);
57  if (!input_snapshot.has_value()) {
58  return std::nullopt;
59  }
60 
61  if (radius_.radius < kEhCloseEnough) {
62  return Entity::FromSnapshot(input_snapshot.value(), entity.GetBlendMode(),
63  entity.GetClipDepth());
64  }
65 
66  auto maybe_input_uvs = input_snapshot->GetCoverageUVs(coverage);
67  if (!maybe_input_uvs.has_value()) {
68  return std::nullopt;
69  }
70  auto input_uvs = maybe_input_uvs.value();
71 
72  //----------------------------------------------------------------------------
73  /// Render to texture.
74  ///
75 
76  ContentContext::SubpassCallback callback = [&](const ContentContext& renderer,
77  RenderPass& pass) {
78  auto& host_buffer = renderer.GetTransientsBuffer();
79 
80  VertexBufferBuilder<VS::PerVertexData> vtx_builder;
81  vtx_builder.AddVertices({
82  {Point(0, 0), input_uvs[0]},
83  {Point(1, 0), input_uvs[1]},
84  {Point(0, 1), input_uvs[2]},
85  {Point(1, 1), input_uvs[3]},
86  });
87 
88  VS::FrameInfo frame_info;
89  frame_info.mvp = Matrix::MakeOrthographic(ISize(1, 1));
90  frame_info.texture_sampler_y_coord_scale =
91  input_snapshot->texture->GetYCoordScale();
92 
93  auto transform = entity.GetTransform() * effect_transform.Basis();
94  auto transformed_radius =
95  transform.TransformDirection(direction_ * radius_.radius);
96  auto transformed_texture_vertices =
97  Rect::MakeSize(input_snapshot->texture->GetSize())
98  .GetTransformedPoints(input_snapshot->transform);
99  auto transformed_texture_width =
100  transformed_texture_vertices[0].GetDistance(
101  transformed_texture_vertices[1]);
102  auto transformed_texture_height =
103  transformed_texture_vertices[0].GetDistance(
104  transformed_texture_vertices[2]);
105 
106  FS::FragInfo frag_info;
107  frag_info.radius = std::round(transformed_radius.GetLength());
108  frag_info.morph_type = static_cast<Scalar>(morph_type_);
109  frag_info.uv_offset =
110  input_snapshot->transform.Invert()
111  .TransformDirection(transformed_radius)
112  .Normalize() /
113  Point(transformed_texture_width, transformed_texture_height);
114 
115  pass.SetCommandLabel("Morphology Filter");
116  auto options = OptionsFromPass(pass);
117  options.primitive_type = PrimitiveType::kTriangleStrip;
118  options.blend_mode = BlendMode::kSource;
119  pass.SetPipeline(renderer.GetMorphologyFilterPipeline(options));
120  pass.SetVertexBuffer(vtx_builder.CreateVertexBuffer(host_buffer));
121 
122  auto sampler_descriptor = input_snapshot->sampler_descriptor;
123  if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
124  sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
125  sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
126  }
127 
128  FS::BindTextureSampler(
129  pass, input_snapshot->texture,
130  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
131  sampler_descriptor));
132  VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
133  FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
134 
135  return pass.Draw().ok();
136  };
137 
138  fml::StatusOr<RenderTarget> render_target = renderer.MakeSubpass(
139  "Directional Morphology Filter", ISize(coverage.GetSize()), callback);
140  if (!render_target.ok()) {
141  return std::nullopt;
142  }
143 
144  SamplerDescriptor sampler_desc;
145  sampler_desc.min_filter = MinMagFilter::kLinear;
146  sampler_desc.mag_filter = MinMagFilter::kLinear;
147 
148  return Entity::FromSnapshot(
149  Snapshot{.texture = render_target.value().GetRenderTargetTexture(),
150  .transform = Matrix::MakeTranslation(coverage.GetOrigin()),
151  .sampler_descriptor = sampler_desc,
152  .opacity = input_snapshot->opacity},
153  entity.GetBlendMode(), entity.GetClipDepth());
154 }
155 
157  const FilterInput::Vector& inputs,
158  const Entity& entity,
159  const Matrix& effect_transform) const {
160  if (inputs.empty()) {
161  return std::nullopt;
162  }
163 
164  auto coverage = inputs[0]->GetCoverage(entity);
165  if (!coverage.has_value()) {
166  return std::nullopt;
167  }
168  auto transform = inputs[0]->GetTransform(entity) * effect_transform.Basis();
169  auto transformed_vector =
170  transform.TransformDirection(direction_ * radius_.radius).Abs();
171 
172  auto origin = coverage->GetOrigin();
173  auto size = Vector2(coverage->GetSize());
174  switch (morph_type_) {
176  origin -= transformed_vector;
177  size += transformed_vector * 2;
178  break;
180  origin += transformed_vector;
181  size -= transformed_vector * 2;
182  break;
183  }
184  if (size.x < 0 || size.y < 0) {
185  return Rect::MakeSize(Size(0, 0));
186  }
187  return Rect::MakeOriginSize(origin, Size(size.x, size.y));
188 }
189 
190 std::optional<Rect>
192  const Matrix& effect_transform,
193  const Rect& output_limit) const {
194  auto transformed_vector =
195  effect_transform.TransformDirection(direction_ * radius_.radius).Abs();
196  switch (morph_type_) {
198  return output_limit.Expand(-transformed_vector);
200  return output_limit.Expand(transformed_vector);
201  }
202 }
203 
204 } // namespace impeller
impeller::OptionsFromPass
ContentContextOptions OptionsFromPass(const RenderPass &pass)
Definition: contents.cc:20
impeller::Radius::radius
Scalar radius
Definition: sigma.h:49
contents.h
impeller::FilterContents::MorphType::kErode
@ kErode
impeller::DirectionalMorphologyFilterContents::~DirectionalMorphologyFilterContents
~DirectionalMorphologyFilterContents() override
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::Entity::GetTransform
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
Definition: entity.cc:49
impeller::kEhCloseEnough
constexpr float kEhCloseEnough
Definition: constants.h:56
impeller::DirectionalMorphologyFilterContents::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: morphology_filter_contents.cc:156
impeller::BlendMode::kSource
@ kSource
formats.h
impeller::Vector2
Point Vector2
Definition: point.h:320
impeller::Entity::FromSnapshot
static Entity FromSnapshot(const Snapshot &snapshot, BlendMode blend_mode=BlendMode::kSourceOver, uint32_t clip_depth=0)
Create an entity that can be used to render a given snapshot.
Definition: entity.cc:22
impeller::RenderPipelineT::FragmentShader
FragmentShader_ FragmentShader
Definition: pipeline.h:94
impeller::Size
TSize< Scalar > Size
Definition: size.h:137
impeller::Matrix::MakeTranslation
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition: matrix.h:95
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:287
impeller::DirectionalMorphologyFilterContents::SetRadius
void SetRadius(Radius radius)
Definition: morphology_filter_contents.cc:23
impeller::TPoint::IsZero
constexpr bool IsZero() const
Definition: point.h:234
impeller::VS
SolidFillVertexShader VS
Definition: stroke_path_geometry.cc:15
impeller::Entity
Definition: entity.h:21
impeller::Matrix::Basis
constexpr Matrix Basis() const
The Matrix without its w components (without translation).
Definition: matrix.h:224
morphology_filter_contents.h
impeller::PrimitiveType::kTriangleStrip
@ kTriangleStrip
impeller::Point
TPoint< Scalar > Point
Definition: point.h:316
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::TRect::GetTransformedPoints
constexpr std::array< TPoint< T >, 4 > GetTransformedPoints(const Matrix &transform) const
Definition: rect.h:394
impeller::MinMagFilter::kLinear
@ kLinear
impeller::TRect< Scalar >::MakeOriginSize
constexpr static TRect MakeOriginSize(const TPoint< Type > &origin, const TSize< Type > &size)
Definition: rect.h:140
impeller::DirectionalMorphologyFilterContents::DirectionalMorphologyFilterContents
DirectionalMorphologyFilterContents()
impeller::DirectionalMorphologyFilterContents::SetDirection
void SetDirection(Vector2 direction)
Definition: morphology_filter_contents.cc:27
impeller::Entity::GetBlendMode
BlendMode GetBlendMode() const
Definition: entity.cc:134
impeller::ContentContext::SubpassCallback
std::function< bool(const ContentContext &, RenderPass &)> SubpassCallback
Definition: content_context.h:783
impeller::Matrix::TransformDirection
constexpr Vector4 TransformDirection(const Vector4 &v) const
Definition: matrix.h:436
impeller::ISize
TSize< int64_t > ISize
Definition: size.h:138
impeller::Entity::GetClipDepth
uint32_t GetClipDepth() const
Definition: entity.cc:105
content_context.h
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:294
impeller::TRect< Scalar >::MakeSize
constexpr static TRect MakeSize(const TSize< U > &size)
Definition: rect.h:146
impeller::FilterContents::MorphType::kDilate
@ kDilate
impeller::TPoint< Scalar >
impeller::DirectionalMorphologyFilterContents::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: morphology_filter_contents.cc:191
impeller::Matrix::MakeOrthographic
static constexpr Matrix MakeOrthographic(TSize< T > size)
Definition: matrix.h:462
impeller::DirectionalMorphologyFilterContents::SetMorphType
void SetMorphType(MorphType morph_type)
Definition: morphology_filter_contents.cc:34
impeller::FilterInput::Vector
std::vector< FilterInput::Ref > Vector
Definition: filter_input.h:33
impeller::TPoint::Normalize
constexpr TPoint Normalize() const
Definition: point.h:208
impeller::RenderPipelineT::VertexShader
VertexShader_ VertexShader
Definition: pipeline.h:93
impeller
Definition: aiks_blur_unittests.cc:20
impeller::ContentContext
Definition: content_context.h:392
impeller::TRect
Definition: rect.h:122
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
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:547
vertex_buffer_builder.h
impeller::SamplerAddressMode::kDecal
@ kDecal
decal sampling mode is only supported on devices that pass the Capabilities.SupportsDecalSamplerAddre...