Flutter Impeller
tiled_texture_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 "fml/logging.h"
10 #include "impeller/entity/tiled_texture_fill.frag.h"
11 #include "impeller/entity/tiled_texture_fill_external.frag.h"
13 
14 namespace impeller {
15 
16 static std::optional<SamplerAddressMode> TileModeToAddressMode(
17  Entity::TileMode tile_mode,
18  const Capabilities& capabilities) {
19  switch (tile_mode) {
22  break;
25  break;
28  break;
30  if (capabilities.SupportsDecalSamplerAddressMode()) {
32  }
33  return std::nullopt;
34  }
35 }
36 
38 
40 
41 void TiledTextureContents::SetTexture(std::shared_ptr<Texture> texture) {
42  texture_ = std::move(texture);
43 }
44 
46  Entity::TileMode y_tile_mode) {
47  x_tile_mode_ = x_tile_mode;
48  y_tile_mode_ = y_tile_mode;
49 }
50 
52  sampler_descriptor_ = desc;
53 }
54 
56  color_filter_ = std::move(color_filter);
57 }
58 
59 std::shared_ptr<Texture> TiledTextureContents::CreateFilterTexture(
60  const ContentContext& renderer) const {
61  if (!color_filter_) {
62  return nullptr;
63  }
64  auto color_filter_contents = color_filter_(FilterInput::Make(texture_));
65  auto snapshot = color_filter_contents->RenderToSnapshot(
66  renderer, // renderer
67  Entity(), // entity
68  std::nullopt, // coverage_limit
69  std::nullopt, // sampler_descriptor
70  true, // msaa_enabled
71  /*mip_count=*/1,
72  "TiledTextureContents Snapshot"); // label
73  if (snapshot.has_value()) {
74  return snapshot.value().texture;
75  }
76  return nullptr;
77 }
78 
79 SamplerDescriptor TiledTextureContents::CreateSamplerDescriptor(
80  const Capabilities& capabilities) const {
81  SamplerDescriptor descriptor = sampler_descriptor_;
82  auto width_mode = TileModeToAddressMode(x_tile_mode_, capabilities);
83  auto height_mode = TileModeToAddressMode(y_tile_mode_, capabilities);
84  if (width_mode.has_value()) {
85  descriptor.width_address_mode = width_mode.value();
86  }
87  if (height_mode.has_value()) {
88  descriptor.height_address_mode = height_mode.value();
89  }
90  return descriptor;
91 }
92 
93 bool TiledTextureContents::UsesEmulatedTileMode(
94  const Capabilities& capabilities) const {
95  return !TileModeToAddressMode(x_tile_mode_, capabilities).has_value() ||
96  !TileModeToAddressMode(y_tile_mode_, capabilities).has_value();
97 }
98 
99 // |Contents|
101  if (GetOpacityFactor() < 1 || x_tile_mode_ == Entity::TileMode::kDecal ||
102  y_tile_mode_ == Entity::TileMode::kDecal) {
103  return false;
104  }
105  if (color_filter_) {
106  return false;
107  }
108  return texture_->IsOpaque() && !AppliesAlphaForStrokeCoverage(transform);
109 }
110 
112  const Entity& entity,
113  RenderPass& pass) const {
114  if (texture_ == nullptr) {
115  return true;
116  }
117 
118  using VS = TextureUvFillVertexShader;
119  using FS = TiledTextureFillFragmentShader;
120 
121  const auto texture_size = texture_->GetSize();
122  if (texture_size.IsEmpty()) {
123  return true;
124  }
125 
126  VS::FrameInfo frame_info;
127  frame_info.texture_sampler_y_coord_scale = texture_->GetYCoordScale();
128  frame_info.uv_transform =
129  Rect::MakeSize(texture_size).GetNormalizingTransform() *
131 
132 #ifdef IMPELLER_ENABLE_OPENGLES
133  using FSExternal = TiledTextureFillExternalFragmentShader;
134  if (texture_->GetTextureDescriptor().type ==
136  return ColorSourceContents::DrawGeometry<VS>(
137  renderer, entity, pass,
138  [&renderer](ContentContextOptions options) {
139  return renderer.GetTiledTextureUvExternalPipeline(options);
140  },
141  frame_info,
142  [this, &renderer](RenderPass& pass) {
143  auto& host_buffer = renderer.GetTransientsBuffer();
144 #ifdef IMPELLER_DEBUG
145  pass.SetCommandLabel("TextureFill External");
146 #endif // IMPELLER_DEBUG
147 
148  FML_DCHECK(!color_filter_);
149  FSExternal::FragInfo frag_info;
150  frag_info.x_tile_mode =
151  static_cast<Scalar>(sampler_descriptor_.width_address_mode);
152  frag_info.y_tile_mode =
153  static_cast<Scalar>(sampler_descriptor_.height_address_mode);
154  frag_info.alpha = GetOpacityFactor();
155  FSExternal::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
156 
157  SamplerDescriptor sampler_desc;
158  // OES_EGL_image_external states that only CLAMP_TO_EDGE is valid,
159  // so we emulate all other tile modes here by remapping the texture
160  // coordinates.
163  sampler_desc.min_filter = sampler_descriptor_.min_filter;
164  sampler_desc.mag_filter = sampler_descriptor_.mag_filter;
165  sampler_desc.mip_filter = MipFilter::kBase;
166 
167  FSExternal::BindSAMPLEREXTERNALOESTextureSampler(
168  pass, texture_,
169  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
170  sampler_desc));
171  return true;
172  });
173  }
174 #endif // IMPELLER_ENABLE_OPENGLES
175 
176  PipelineBuilderCallback pipeline_callback =
177  [&renderer](ContentContextOptions options) {
178  return renderer.GetTiledTexturePipeline(options);
179  };
180  return ColorSourceContents::DrawGeometry<VS>(
181  renderer, entity, pass, pipeline_callback, frame_info,
182  [this, &renderer, &entity](RenderPass& pass) {
183  auto& host_buffer = renderer.GetTransientsBuffer();
184 #ifdef IMPELLER_DEBUG
185  pass.SetCommandLabel("TextureFill");
186 #endif // IMPELLER_DEBUG
187 
188  FS::FragInfo frag_info;
189  frag_info.x_tile_mode = static_cast<Scalar>(x_tile_mode_);
190  frag_info.y_tile_mode = static_cast<Scalar>(y_tile_mode_);
191  frag_info.alpha =
192  GetOpacityFactor() *
194  FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
195 
196  if (color_filter_) {
197  auto filtered_texture = CreateFilterTexture(renderer);
198  if (!filtered_texture) {
199  return false;
200  }
201  FS::BindTextureSampler(
202  pass, filtered_texture,
203  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
204  CreateSamplerDescriptor(renderer.GetDeviceCapabilities())));
205  } else {
206  FS::BindTextureSampler(
207  pass, texture_,
208  renderer.GetContext()->GetSamplerLibrary()->GetSampler(
209  CreateSamplerDescriptor(renderer.GetDeviceCapabilities())));
210  }
211 
212  return true;
213  });
214 }
215 
217  const ContentContext& renderer,
218  const Entity& entity,
219  std::optional<Rect> coverage_limit,
220  const std::optional<SamplerDescriptor>& sampler_descriptor,
221  bool msaa_enabled,
222  int32_t mip_count,
223  std::string_view label) const {
224  std::optional<Rect> geometry_coverage = GetGeometry()->GetCoverage({});
225  if (GetInverseEffectTransform().IsIdentity() &&
226  GetGeometry()->IsAxisAlignedRect() &&
227  (!geometry_coverage.has_value() ||
228  Rect::MakeSize(texture_->GetSize())
229  .Contains(geometry_coverage.value()))) {
230  auto coverage = GetCoverage(entity);
231  if (!coverage.has_value()) {
232  return std::nullopt;
233  }
234  auto scale = Vector2(coverage->GetSize() / Size(texture_->GetSize()));
235 
236  return Snapshot{
237  .texture = texture_,
238  .transform = Matrix::MakeTranslation(coverage->GetOrigin()) *
239  Matrix::MakeScale(scale),
240  .sampler_descriptor = sampler_descriptor.value_or(sampler_descriptor_),
241  .opacity = GetOpacityFactor(),
242  };
243  }
244 
246  renderer, // renderer
247  entity, // entity
248  std::nullopt, // coverage_limit
249  sampler_descriptor.value_or(sampler_descriptor_), // sampler_descriptor
250  true, // msaa_enabled
251  /*mip_count=*/1,
252  label); // label
253 }
254 
255 } // namespace impeller
virtual bool SupportsDecalSamplerAddressMode() const =0
Whether the context backend supports SamplerAddressMode::Decal.
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.
std::optional< Rect > GetCoverage(const Entity &entity) const override
Get the area of the render pass that will be affected when this contents is rendered.
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 GetTiledTexturePipeline(ContentContextOptions opts) const
const Capabilities & GetDeviceCapabilities() const
std::shared_ptr< Context > GetContext() const
virtual std::optional< Snapshot > RenderToSnapshot(const ContentContext &renderer, const Entity &entity, std::optional< Rect > coverage_limit=std::nullopt, const std::optional< SamplerDescriptor > &sampler_descriptor=std::nullopt, bool msaa_enabled=true, int32_t mip_count=1, std::string_view label="Snapshot") const
Render this contents to a snapshot, respecting the entity's transform, path, clip depth,...
Definition: contents.cc:56
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
static FilterInput::Ref Make(Variant input, bool msaa_enabled=true)
Definition: filter_input.cc:19
virtual Scalar ComputeAlphaCoverage(const Matrix &transform) const
Definition: geometry.h:125
virtual std::optional< Rect > GetCoverage(const Matrix &transform) const =0
Render passes encode render commands directed as one specific render target into an underlying comman...
Definition: render_pass.h:30
virtual void SetCommandLabel(std::string_view label)
The debugging label to use for the command.
Definition: render_pass.cc:97
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
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 SetSamplerDescriptor(const SamplerDescriptor &desc)
void SetColorFilter(ColorFilterProc color_filter)
Set a color filter to apply directly to this tiled texture.
void SetTileModes(Entity::TileMode x_tile_mode, Entity::TileMode y_tile_mode)
std::optional< Snapshot > RenderToSnapshot(const ContentContext &renderer, const Entity &entity, std::optional< Rect > coverage_limit=std::nullopt, const std::optional< SamplerDescriptor > &sampler_descriptor=std::nullopt, bool msaa_enabled=true, int32_t mip_count=1, std::string_view label="Tiled Texture Snapshot") const override
Render this contents to a snapshot, respecting the entity's transform, path, clip depth,...
void SetTexture(std::shared_ptr< Texture > texture)
Point Vector2
Definition: point.h:331
float Scalar
Definition: scalar.h:19
@ kDecal
decal sampling mode is only supported on devices that pass the Capabilities.SupportsDecalSamplerAddre...
LinePipeline::FragmentShader FS
@ kBase
The texture is sampled as if it only had a single mipmap level.
static std::optional< SamplerAddressMode > TileModeToAddressMode(Entity::TileMode tile_mode, const Capabilities &capabilities)
LinePipeline::VertexShader VS
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
static constexpr Matrix MakeTranslation(const Vector3 &t)
Definition: matrix.h:95
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
SamplerAddressMode width_address_mode
SamplerAddressMode height_address_mode
Represents a texture and its intended draw transform/sampler configuration.
Definition: snapshot.h:24
std::shared_ptr< Texture > texture
Definition: snapshot.h:25
constexpr bool Contains(const TPoint< Type > &p) const
Returns true iff the provided point |p| is inside the half-open interior of this rectangle.
Definition: rect.h:235
constexpr Matrix GetNormalizingTransform() const
Constructs a Matrix that will map all points in the coordinate space of the rectangle into a new norm...
Definition: rect.h:495
constexpr static TRect MakeSize(const TSize< U > &size)
Definition: rect.h:150