| Flutter Impeller |

Classes | Public Member Functions | Static Public Member Functions | List of all members
impeller::RuntimeEffectContents Class Referencefinal

`#include <runtime_effect_contents.h>`

Inheritance diagram for impeller::RuntimeEffectContents:

## Classes
struct | TextureInput

## Public Member Functions
void | SetRuntimeStage (std::shared_ptr< RuntimeStage > runtime_stage)
void | SetUniformData (std::shared_ptr< std::vector< uint8_t >> uniform_data)
void | SetTextureInputs (std::vector< TextureInput > texture_inputs)
bool | Render (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
bool | BootstrapShader (const ContentContext &renderer) const
| Load the runtime effect and ensure a default PSO is initialized. More...
Public Member Functions inherited from impeller::ColorSourceContents
| ColorSourceContents ()
| ~ColorSourceContents () override
void | SetGeometry (const Geometry *geometry)
| Set the geometry that this contents will use to render. More...
const Geometry * | GetGeometry () const
| Get the geometry that this contents will use to render. More...
void | SetEffectTransform (Matrix matrix)
| Set the effect transform for this color source. More...
const Matrix & | GetInverseEffectTransform () const
| Set the inverted effect transform for this color source. More...
void | SetOpacityFactor (Scalar opacity)
| Set the opacity factor for this color source. More...
Scalar | GetOpacityFactor () const
| Get the opacity factor for this color source. More...
virtual bool | IsSolidColor () const
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. More...
void | SetInheritedOpacity (Scalar opacity) override
| Inherit the provided opacity. More...
Public Member Functions inherited from impeller::Contents
| Contents ()
virtual | ~Contents ()
void | SetCoverageHint (std::optional< Rect > coverage_hint)
| Hint that specifies the coverage area of this Contents that will actually be used during rendering. This is for optimization purposes only and can not be relied on as a clip. May optionally affect the result of `GetCoverage()`. More...
const std::optional< Rect > & | GetCoverageHint () const
virtual bool | IsOpaque (const Matrix &transform) const
| Whether this Contents only emits opaque source colors from the fragment stage. This value does not account for any entity properties (e.g. the blend mode), clips/visibility culling, or inherited opacity. More...
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, and blend mode. The result texture size is always the size of `GetCoverage(entity)`. More...
std::optional< Size > | GetColorSourceSize () const
| Return the color source's intrinsic size, if available. More...
void | SetColorSourceSize (Size size)
virtual std::optional< Color > | AsBackgroundColor (const Entity &entity, ISize target_size) const
| Returns a color if this Contents will flood the given `target_size` with a color. This output color is the "Source" color that will be used for the Entity's blend operation. More...
virtual bool | ApplyColorFilter (const ColorFilterProc &color_filter_proc)
| If possible, applies a color filter to this contents inputs on the CPU. More...

## Static Public Member Functions
static BufferView | EmplaceVulkanUniform (const std::shared_ptr< const std::vector< uint8_t >> &input_data, HostBuffer &host_buffer, const RuntimeUniformDescription &uniform)
Static Public Member Functions inherited from impeller::ColorSourceContents
template<typename VertexShaderT >
static bool | DrawGeometry (const Contents *contents, const Geometry *geometry, const ContentContext &renderer, const Entity &entity, RenderPass &pass, const PipelineBuilderCallback &pipeline_callback, typename VertexShaderT::FrameInfo frame_info, const BindFragmentCallback &bind_fragment_callback, bool force_stencil=false, const CreateGeometryCallback &create_geom_callback=DefaultCreateGeometryCallback)
Static Public Member Functions inherited from impeller::Contents
static std::shared_ptr< Contents > | MakeAnonymous (RenderProc render_proc, CoverageProc coverage_proc)

## Additional Inherited Members
Public Types inherited from impeller::ColorSourceContents
using | BindFragmentCallback = std::function< bool(RenderPass &pass)>
using | PipelineBuilderCallback = std::function< PipelineRef(ContentContextOptions)>
using | CreateGeometryCallback = std::function< GeometryResult(const ContentContext &renderer, const Entity &entity, RenderPass &pass, const Geometry *geom)>
Public Types inherited from impeller::Contents
using | ColorFilterProc = std::function< Color(Color)>
using | RenderProc = std::function< bool(const ContentContext &renderer, const Entity &entity, RenderPass &pass)>
using | CoverageProc = std::function< std::optional< Rect >(const Entity &entity)>
Protected Member Functions inherited from impeller::ColorSourceContents
bool | AppliesAlphaForStrokeCoverage (const Matrix &transform) const
| Whether the entity should be treated as non-opaque due to stroke geometry requiring alpha for coverage. More...
template<typename VertexShaderT >
bool | DrawGeometry (const ContentContext &renderer, const Entity &entity, RenderPass &pass, const PipelineBuilderCallback &pipeline_callback, typename VertexShaderT::FrameInfo frame_info, const BindFragmentCallback &bind_fragment_callback, bool force_stencil=false, const CreateGeometryCallback &create_geom_callback=DefaultCreateGeometryCallback) const
Static Protected Member Functions inherited from impeller::ColorSourceContents
static GeometryResult | DefaultCreateGeometryCallback (const ContentContext &renderer, const Entity &entity, RenderPass &pass, const Geometry *geom)

## Detailed Description

Definition at line 18 of file runtime_effect_contents.h.

## Member Function Documentation

## ◆ BootstrapShader()

bool impeller::RuntimeEffectContents::BootstrapShader | ( | const ContentContext & | renderer | ) | const

Load the runtime effect and ensure a default PSO is initialized.

Definition at line 98 of file runtime_effect_contents.cc.

99 {
100 if (!RegisterShader(renderer)) {
101 return false;
102 }
103 ContentContextOptions options;
104 options.color_attachment_pixel_format =
105 renderer.GetContext()->GetCapabilities()->GetDefaultColorFormat();
106 CreatePipeline(renderer, options, /*async=*/true);
107 return true;
108 }

References impeller::ContentContextOptions::color_attachment_pixel_format, and impeller::ContentContext::GetContext().

## ◆ EmplaceVulkanUniform()

BufferView impeller::RuntimeEffectContents::EmplaceVulkanUniform | ( | const std::shared_ptr< const std::vector< uint8_t >> & | input_data,
|  | HostBuffer & | host_buffer,
|  | const RuntimeUniformDescription & | uniform
| ) |  |
| static

Definition at line 33 of file runtime_effect_contents.cc.

36 {
37 // TODO(jonahwilliams): rewrite this to emplace directly into
38 // HostBuffer.
39 std::vector<float> uniform_buffer;
40 uniform_buffer.reserve(uniform.struct_layout.size());
41 size_t uniform_byte_index = 0u;
42 for (char byte_type : uniform.struct_layout) {
43 if (byte_type == kPaddingType) {
44 uniform_buffer.push_back(0.f);
45 } else {
46 FML_DCHECK(byte_type == kFloatType);
47 uniform_buffer.push_back(reinterpret_cast<const float*>(
48 input_data->data())[uniform_byte_index++]);
49 }
50 }
51 size_t alignment = std::max(sizeof(float) * uniform_buffer.size(),
52 DefaultUniformAlignment());
53
54 return host_buffer.Emplace(
55 reinterpret_cast<const void*>(uniform_buffer.data()),
56 sizeof(float) * uniform_buffer.size(), alignment);
57 }
impeller::DefaultUniformAlignment
constexpr size_t DefaultUniformAlignment()
Definition: platform.h:14

References impeller::DefaultUniformAlignment(), impeller::HostBuffer::Emplace(), and impeller::RuntimeUniformDescription::struct_layout.

Referenced by Render(), and impeller::testing::TEST_P().

## ◆ Render()

bool impeller::RuntimeEffectContents::Render | ( | const ContentContext & | renderer,
|  | const Entity & | entity,
|  | RenderPass & | pass
| ) |  | const
| override virtual

Get or register shader. Flutter will do this when the runtime effect is first loaded, but this check is added to supporting testing of the Aiks API and non-flutter usage of Impeller.

Fragment stage uniforms.

Now that the descriptor set layouts are known, get the pipeline.

Implements impeller::Contents.

Definition at line 217 of file runtime_effect_contents.cc.

219 {
220 const std::shared_ptr<Context>& context = renderer.GetContext();
221 const std::shared_ptr<ShaderLibrary>& library = context->GetShaderLibrary();
222
223 //--------------------------------------------------------------------------
224 /// Get or register shader. Flutter will do this when the runtime effect
225 /// is first loaded, but this check is added to supporting testing of the
226 /// Aiks API and non-flutter usage of Impeller.
227 ///
228 if (!RegisterShader(renderer)) {
229 return false;
230 }
231
232 //--------------------------------------------------------------------------
233 /// Fragment stage uniforms.
234 ///
235 BindFragmentCallback bind_callback = [this, &renderer,
236 &context](RenderPass& pass) {
237 size_t buffer_index = 0;
238 size_t buffer_offset = 0;
239 size_t sampler_location = 0;
240 size_t buffer_location = 0;
241
242 // Uniforms are ordered in the IPLR according to their
243 // declaration and the uniform location reflects the correct offset to
244 // be mapped to - except that it may include all proceeding
245 // uniforms of a different type. For example, a texture sampler that comes
246 // after 4 float uniforms may have a location of 4. Since we know that
247 // the declarations are already ordered, we can track the uniform location
248 // ourselves.
249 for (const auto& uniform : runtime_stage_->GetUniforms()) {
250 std::unique_ptr<ShaderMetadata> metadata = MakeShaderMetadata(uniform);
251 switch (uniform.type) {
252 case kSampledImage: {
253 FML_DCHECK(sampler_location < texture_inputs_.size());
254 auto& input = texture_inputs_[sampler_location];
255
256 raw_ptr<const Sampler> sampler =
257 context->GetSamplerLibrary()->GetSampler(
258 input.sampler_descriptor);
259
260 SampledImageSlot image_slot;
261 image_slot.name = uniform.name.c_str();
262 image_slot.binding = uniform.binding;
263 image_slot.texture_index = sampler_location;
264 pass.BindDynamicResource(ShaderStage::kFragment,
265 DescriptorType::kSampledImage, image_slot,
266 std::move(metadata), input.texture, sampler);
267 sampler_location++;
268 break;
269 }
270 case kFloat: {
271 FML_DCHECK(renderer.GetContext()->GetBackendType() !=
272 Context::BackendType::kVulkan)
273 << "Uniform " << uniform.name
274 << " had unexpected type kFloat for Vulkan backend.";
275
276 size_t alignment =
277 std::max(uniform.bit_width / 8, DefaultUniformAlignment());
278 BufferView buffer_view = renderer.GetTransientsBuffer().Emplace(
279 uniform_data_->data() + buffer_offset, uniform.GetSize(),
280 alignment);
281
282 ShaderUniformSlot uniform_slot;
283 uniform_slot.name = uniform.name.c_str();
284 uniform_slot.ext_res_0 = buffer_location;
285 pass.BindDynamicResource(ShaderStage::kFragment,
286 DescriptorType::kUniformBuffer, uniform_slot,
287 std::move(metadata), std::move(buffer_view));
288 buffer_index++;
289 buffer_offset += uniform.GetSize();
290 buffer_location++;
291 break;
292 }
293 case kStruct: {
294 FML_DCHECK(renderer.GetContext()->GetBackendType() ==
295 Context::BackendType::kVulkan);
296 ShaderUniformSlot uniform_slot;
297 uniform_slot.binding = uniform.location;
298 uniform_slot.name = uniform.name.c_str();
299
300 pass.BindResource(
301 ShaderStage::kFragment, DescriptorType::kUniformBuffer,
302 uniform_slot, nullptr,
303 EmplaceVulkanUniform(uniform_data_,
304 renderer.GetTransientsBuffer(), uniform));
305 }
306 }
307 }
308
309 return true;
310 };
311
312 /// Now that the descriptor set layouts are known, get the pipeline.
313 using VS = RuntimeEffectVertexShader;
314
315 PipelineBuilderCallback pipeline_callback =
316 [&](ContentContextOptions options) {
317 // Pipeline creation callback for the cache handler to call.
318 return renderer.GetCachedRuntimeEffectPipeline(
319 runtime_stage_->GetEntrypoint(), options, [&]() {
320 return CreatePipeline(renderer, options, /*async=*/false);
321 });
322 };
323
324 return ColorSourceContents::DrawGeometry<VS>(renderer, entity, pass,
325 pipeline_callback,
326 VS::FrameInfo{}, bind_callback);
327 }
buffer_view
BufferView buffer_view
Definition: blit_command_gles.cc:152
impeller::ColorSourceContents::PipelineBuilderCallback
std::function< PipelineRef(ContentContextOptions)> PipelineBuilderCallback
Definition: color_source_contents.h:42
impeller::ColorSourceContents::BindFragmentCallback
std::function< bool(RenderPass &pass)> BindFragmentCallback
Definition: color_source_contents.h:40
impeller::Context::BackendType::kVulkan
@ kVulkan
impeller::RuntimeEffectContents::EmplaceVulkanUniform
static BufferView EmplaceVulkanUniform(const std::shared_ptr< const std::vector< uint8_t >> &input_data, HostBuffer &host_buffer, const RuntimeUniformDescription &uniform)
Definition: runtime_effect_contents.cc:33
impeller::MakeShaderMetadata
static std::unique_ptr< ShaderMetadata > MakeShaderMetadata(const RuntimeUniformDescription &uniform)
Definition: runtime_effect_contents.cc:85
impeller::ShaderStage::kFragment
@ kFragment
impeller::VS
LinePipeline::VertexShader VS
Definition: line_contents.cc:13
impeller::DescriptorType::kUniformBuffer
@ kUniformBuffer
impeller::DescriptorType::kSampledImage
@ kSampledImage
impeller::kSampledImage
@ kSampledImage
Definition: runtime_types.h:26
impeller::kFloat
@ kFloat
Definition: runtime_types.h:25
impeller::kStruct
@ kStruct
Definition: runtime_types.h:27

References impeller::RenderPass::BindDynamicResource(), impeller::ShaderUniformSlot::binding, impeller::SampledImageSlot::binding, impeller::RenderPass::BindResource(), buffer_view, impeller::DefaultUniformAlignment(), impeller::HostBuffer::Emplace(), EmplaceVulkanUniform(), impeller::ShaderUniformSlot::ext_res_0, impeller::ContentContext::GetCachedRuntimeEffectPipeline(), impeller::ContentContext::GetContext(), impeller::ContentContext::GetTransientsBuffer(), impeller::kFloat, impeller::kFragment, impeller::kSampledImage, impeller::kStruct, impeller::kUniformBuffer, impeller::Context::kVulkan, impeller::MakeShaderMetadata(), impeller::ShaderUniformSlot::name, impeller::SampledImageSlot::name, and impeller::SampledImageSlot::texture_index.

## ◆ SetRuntimeStage()

void impeller::RuntimeEffectContents::SetRuntimeStage | ( | std::shared_ptr< RuntimeStage > | runtime_stage | ) |

Definition at line 59 of file runtime_effect_contents.cc.

60 {
61 runtime_stage_ = std::move(runtime_stage);
62 }

## ◆ SetTextureInputs()

void impeller::RuntimeEffectContents::SetTextureInputs | ( | std::vector< TextureInput > | texture_inputs | ) |

Definition at line 69 of file runtime_effect_contents.cc.

70 {
71 texture_inputs_ = std::move(texture_inputs);
72 }

## ◆ SetUniformData()

void impeller::RuntimeEffectContents::SetUniformData | ( | std::shared_ptr< std::vector< uint8_t >> | uniform_data | ) |

Definition at line 64 of file runtime_effect_contents.cc.

65 {
66 uniform_data_ = std::move(uniform_data);
67 }

The documentation for this class was generated from the following files:

- impeller/entity/contents/runtime_effect_contents.h
- impeller/entity/contents/runtime_effect_contents.cc