| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "impeller/entity/entity_pass.h" |
| |
| #include <variant> |
| |
| #include "flutter/fml/logging.h" |
| #include "flutter/fml/trace_event.h" |
| #include "impeller/base/validation.h" |
| #include "impeller/entity/contents/content_context.h" |
| #include "impeller/entity/contents/filters/filter_contents.h" |
| #include "impeller/entity/contents/filters/inputs/filter_input.h" |
| #include "impeller/entity/contents/texture_contents.h" |
| #include "impeller/geometry/path_builder.h" |
| #include "impeller/renderer/allocator.h" |
| #include "impeller/renderer/command.h" |
| #include "impeller/renderer/command_buffer.h" |
| #include "impeller/renderer/formats.h" |
| #include "impeller/renderer/render_pass.h" |
| #include "impeller/renderer/texture.h" |
| |
| namespace impeller { |
| |
| EntityPass::EntityPass() = default; |
| |
| EntityPass::~EntityPass() = default; |
| |
| void EntityPass::SetDelegate(std::unique_ptr<EntityPassDelegate> delegate) { |
| if (!delegate) { |
| return; |
| } |
| delegate_ = std::move(delegate); |
| } |
| |
| void EntityPass::AddEntity(Entity entity) { |
| if (entity.GetBlendMode() > Entity::BlendMode::kLastPipelineBlendMode) { |
| contains_advanced_blends_ = true; |
| } |
| |
| elements_.emplace_back(std::move(entity)); |
| } |
| |
| void EntityPass::SetElements(std::vector<Element> elements) { |
| elements_ = std::move(elements); |
| } |
| |
| size_t EntityPass::GetSubpassesDepth() const { |
| size_t max_subpass_depth = 0u; |
| for (const auto& element : elements_) { |
| if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) { |
| max_subpass_depth = |
| std::max(max_subpass_depth, subpass->get()->GetSubpassesDepth()); |
| } |
| } |
| return max_subpass_depth + 1u; |
| } |
| |
| const std::shared_ptr<LazyGlyphAtlas>& EntityPass::GetLazyGlyphAtlas() const { |
| return lazy_glyph_atlas_; |
| } |
| |
| std::optional<Rect> EntityPass::GetElementsCoverage() const { |
| std::optional<Rect> result; |
| for (const auto& element : elements_) { |
| std::optional<Rect> coverage; |
| |
| if (auto entity = std::get_if<Entity>(&element)) { |
| coverage = entity->GetCoverage(); |
| } else if (auto subpass = |
| std::get_if<std::unique_ptr<EntityPass>>(&element)) { |
| coverage = GetSubpassCoverage(*subpass->get()); |
| } else { |
| FML_UNREACHABLE(); |
| } |
| |
| if (!result.has_value() && coverage.has_value()) { |
| result = coverage; |
| continue; |
| } |
| if (!coverage.has_value()) { |
| continue; |
| } |
| result = result->Union(coverage.value()); |
| } |
| return result; |
| } |
| |
| std::optional<Rect> EntityPass::GetSubpassCoverage( |
| const EntityPass& subpass) const { |
| auto entities_coverage = subpass.GetElementsCoverage(); |
| // The entities don't cover anything. There is nothing to do. |
| if (!entities_coverage.has_value()) { |
| return std::nullopt; |
| } |
| |
| // The delegates don't have an opinion on what the entity coverage has to be. |
| // Just use that as-is. |
| auto delegate_coverage = subpass.delegate_->GetCoverageRect(); |
| if (!delegate_coverage.has_value()) { |
| return entities_coverage; |
| } |
| // The delegate coverage hint is in given in local space, so apply the subpass |
| // transformation. |
| delegate_coverage = delegate_coverage->TransformBounds(subpass.xformation_); |
| |
| // If the delegate tells us the coverage is smaller than it needs to be, then |
| // great. OTOH, if the delegate is being wasteful, limit coverage to what is |
| // actually needed. |
| return entities_coverage->Intersection(delegate_coverage.value()); |
| } |
| |
| EntityPass* EntityPass::GetSuperpass() const { |
| return superpass_; |
| } |
| |
| EntityPass* EntityPass::AddSubpass(std::unique_ptr<EntityPass> pass) { |
| if (!pass) { |
| return nullptr; |
| } |
| FML_DCHECK(pass->superpass_ == nullptr); |
| pass->superpass_ = this; |
| |
| if (pass->blend_mode_ > Entity::BlendMode::kLastPipelineBlendMode) { |
| contains_advanced_blends_ = true; |
| } |
| |
| auto subpass_pointer = pass.get(); |
| elements_.emplace_back(std::move(pass)); |
| return subpass_pointer; |
| } |
| |
| bool EntityPass::Render(ContentContext& renderer, |
| RenderTarget render_target) const { |
| if (contains_advanced_blends_) { |
| auto offscreen_target = RenderTarget::CreateOffscreen( |
| *renderer.GetContext(), render_target.GetRenderTargetSize(), |
| "EntityPass", // |
| StorageMode::kDevicePrivate, LoadAction::kClear, StoreAction::kStore, |
| StorageMode::kDevicePrivate, LoadAction::kClear, StoreAction::kStore); |
| if (!RenderInternal(renderer, offscreen_target, Point(), 0)) { |
| return false; |
| } |
| |
| auto command_buffer = renderer.GetContext()->CreateRenderCommandBuffer(); |
| command_buffer->SetLabel("EntityPass Root Command Buffer"); |
| auto render_pass = command_buffer->CreateRenderPass(render_target); |
| render_pass->SetLabel("EntityPass Root Render Pass"); |
| |
| { |
| auto size_rect = |
| Rect::MakeSize(Size(offscreen_target.GetRenderTargetSize())); |
| auto contents = std::make_shared<TextureContents>(); |
| contents->SetPath(PathBuilder{}.AddRect(size_rect).TakePath()); |
| contents->SetTexture(offscreen_target.GetRenderTargetTexture()); |
| contents->SetSourceRect(size_rect); |
| |
| Entity entity; |
| entity.SetContents(contents); |
| entity.SetBlendMode(Entity::BlendMode::kSourceOver); |
| |
| entity.Render(renderer, *render_pass); |
| } |
| |
| if (!render_pass->EncodeCommands( |
| renderer.GetContext()->GetTransientsAllocator())) { |
| return false; |
| } |
| if (!command_buffer->SubmitCommands()) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| return RenderInternal(renderer, render_target, Point(), 0); |
| } |
| |
| bool EntityPass::RenderInternal(ContentContext& renderer, |
| RenderTarget render_target, |
| Point position, |
| uint32_t pass_depth, |
| size_t stencil_depth_floor) const { |
| TRACE_EVENT0("impeller", "EntityPass::Render"); |
| |
| auto context = renderer.GetContext(); |
| |
| std::shared_ptr<CommandBuffer> command_buffer; |
| std::shared_ptr<RenderPass> pass; |
| uint32_t pass_count = 0; |
| |
| auto end_pass = [&command_buffer, &pass, &context]() { |
| if (!pass->EncodeCommands(context->GetTransientsAllocator())) { |
| return false; |
| } |
| |
| if (!command_buffer->SubmitCommands()) { |
| return false; |
| } |
| |
| return true; |
| }; |
| |
| for (const auto& element : elements_) { |
| Entity element_entity; |
| |
| // ========================================================================= |
| // Setup entity element for rendering ====================================== |
| // ========================================================================= |
| if (const auto& entity = std::get_if<Entity>(&element)) { |
| element_entity = *entity; |
| if (!position.IsZero()) { |
| // If the pass image is going to be rendered with a non-zero position, |
| // apply the negative translation to entity copies before rendering them |
| // so that they'll end up rendering to the correct on-screen position. |
| element_entity.SetTransformation( |
| Matrix::MakeTranslation(Vector3(-position)) * |
| element_entity.GetTransformation()); |
| } |
| } |
| |
| // ========================================================================= |
| // Setup subpass element for rendering ===================================== |
| // ========================================================================= |
| else if (const auto& subpass_ptr = |
| std::get_if<std::unique_ptr<EntityPass>>(&element)) { |
| auto subpass = subpass_ptr->get(); |
| |
| if (subpass->delegate_->CanElide()) { |
| continue; |
| } |
| |
| if (subpass->delegate_->CanCollapseIntoParentPass()) { |
| // Directly render into the parent target and move on. |
| if (!subpass->RenderInternal(renderer, render_target, position, |
| pass_depth, stencil_depth_floor)) { |
| return false; |
| } |
| continue; |
| } |
| |
| const auto subpass_coverage = GetSubpassCoverage(*subpass); |
| if (!subpass_coverage.has_value()) { |
| continue; |
| } |
| |
| if (subpass_coverage->size.IsEmpty()) { |
| // It is not an error to have an empty subpass. But subpasses that can't |
| // create their intermediates must trip errors. |
| continue; |
| } |
| |
| RenderTarget subpass_target; |
| if (subpass->contains_advanced_blends_) { |
| subpass_target = RenderTarget::CreateOffscreen( |
| *context, ISize::Ceil(subpass_coverage->size), "EntityPass", |
| StorageMode::kDevicePrivate, LoadAction::kClear, |
| StoreAction::kStore, StorageMode::kDevicePrivate, |
| LoadAction::kClear, StoreAction::kStore); |
| } else { |
| subpass_target = RenderTarget::CreateOffscreen( |
| *context, ISize::Ceil(subpass_coverage->size), "EntityPass", |
| StorageMode::kDevicePrivate, LoadAction::kClear, |
| StoreAction::kStore, StorageMode::kDeviceTransient, |
| LoadAction::kClear, StoreAction::kDontCare); |
| } |
| |
| auto subpass_texture = subpass_target.GetRenderTargetTexture(); |
| |
| if (!subpass_texture) { |
| return false; |
| } |
| |
| auto offscreen_texture_contents = |
| subpass->delegate_->CreateContentsForSubpassTarget(subpass_texture); |
| |
| if (!offscreen_texture_contents) { |
| // This is an error because the subpass delegate said the pass couldn't |
| // be collapsed into its parent. Yet, when asked how it want's to |
| // postprocess the offscreen texture, it couldn't give us an answer. |
| // |
| // Theoretically, we could collapse the pass now. But that would be |
| // wasteful as we already have the offscreen texture and we don't want |
| // to discard it without ever using it. Just make the delegate do the |
| // right thing. |
| return false; |
| } |
| |
| // Stencil textures aren't shared between EntityPasses (as much of the |
| // time they are transient). |
| if (!subpass->RenderInternal(renderer, subpass_target, |
| subpass_coverage->origin, ++pass_depth, |
| subpass->stencil_depth_)) { |
| return false; |
| } |
| |
| element_entity.SetContents(std::move(offscreen_texture_contents)); |
| element_entity.SetStencilDepth(subpass->stencil_depth_); |
| element_entity.SetBlendMode(subpass->blend_mode_); |
| // Once we have filters being applied for SaveLayer, some special sauce |
| // may be needed here (or in PaintPassDelegate) to ensure the filter |
| // parameters are transformed by the `xformation_` matrix, while |
| // continuing to apply only the subpass offset to the offscreen texture. |
| element_entity.SetTransformation(Matrix::MakeTranslation( |
| Vector3(subpass_coverage->origin - position))); |
| } else { |
| FML_UNREACHABLE(); |
| } |
| |
| // ========================================================================= |
| // Configure the RenderPass ================================================ |
| // ========================================================================= |
| |
| if (pass && element_entity.GetBlendMode() > |
| Entity::BlendMode::kLastPipelineBlendMode) { |
| // End the active pass and flush the buffer before rendering "advanced" |
| // blends. Advanced blends work by binding the current render target |
| // texture as an input ("destination"), blending with a second texture |
| // input ("source"), writing the result to an intermediate texture, and |
| // finally copying the data from the intermediate texture back to the |
| // render target texture. And so all of the commands that have written to |
| // the render target texture so far need to execute before it's bound for |
| // blending (otherwise the blend pass will end up executing before all the |
| // previous commands in the active pass). |
| if (!end_pass()) { |
| return false; |
| } |
| // Resetting these handles triggers a new pass to get created below |
| pass = nullptr; |
| command_buffer = nullptr; |
| |
| // Amend an advanced blend to the contents. |
| if (render_target.GetColorAttachments().empty()) { |
| return false; |
| } |
| auto color0 = render_target.GetColorAttachments().find(0)->second; |
| |
| FilterInput::Vector inputs = { |
| FilterInput::Make(element_entity.GetContents()), |
| FilterInput::Make( |
| color0.resolve_texture ? color0.resolve_texture : color0.texture, |
| element_entity.GetTransformation().Invert())}; |
| element_entity.SetContents( |
| FilterContents::MakeBlend(element_entity.GetBlendMode(), inputs)); |
| element_entity.SetBlendMode(Entity::BlendMode::kSourceOver); |
| } |
| |
| // Create a new render pass to render the element if one isn't active. |
| if (!pass) { |
| command_buffer = context->CreateRenderCommandBuffer(); |
| if (!command_buffer) { |
| return false; |
| } |
| |
| command_buffer->SetLabel( |
| "EntityPass Command Buffer: Depth=" + std::to_string(pass_depth) + |
| " Count=" + std::to_string(pass_count)); |
| |
| // Never clear the texture for subsequent passes. |
| if (pass_count > 0) { |
| if (!render_target.GetColorAttachments().empty()) { |
| auto color0 = render_target.GetColorAttachments().find(0)->second; |
| color0.load_action = LoadAction::kLoad; |
| render_target.SetColorAttachment(color0, 0); |
| } |
| |
| if (auto stencil = render_target.GetStencilAttachment(); |
| stencil.has_value()) { |
| stencil->load_action = LoadAction::kLoad; |
| render_target.SetStencilAttachment(stencil.value()); |
| } |
| } |
| |
| pass = command_buffer->CreateRenderPass(render_target); |
| if (!pass) { |
| return false; |
| } |
| |
| pass->SetLabel( |
| "EntityPass Render Pass: Depth=" + std::to_string(pass_depth) + |
| " Count=" + std::to_string(pass_count)); |
| |
| ++pass_count; |
| } |
| |
| // ========================================================================= |
| // Render the element ====================================================== |
| // ========================================================================= |
| |
| element_entity.SetStencilDepth(element_entity.GetStencilDepth() - |
| stencil_depth_floor); |
| |
| if (!element_entity.Render(renderer, *pass)) { |
| return false; |
| } |
| } |
| |
| if (pass) { |
| return end_pass(); |
| } |
| return true; |
| } |
| |
| void EntityPass::IterateAllEntities(std::function<bool(Entity&)> iterator) { |
| if (!iterator) { |
| return; |
| } |
| |
| for (auto& element : elements_) { |
| if (auto entity = std::get_if<Entity>(&element)) { |
| if (!iterator(*entity)) { |
| return; |
| } |
| continue; |
| } |
| if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) { |
| subpass->get()->IterateAllEntities(iterator); |
| continue; |
| } |
| FML_UNREACHABLE(); |
| } |
| } |
| |
| std::unique_ptr<EntityPass> EntityPass::Clone() const { |
| std::vector<Element> new_elements; |
| new_elements.reserve(elements_.size()); |
| |
| for (const auto& element : elements_) { |
| if (auto entity = std::get_if<Entity>(&element)) { |
| new_elements.push_back(*entity); |
| continue; |
| } |
| if (auto subpass = std::get_if<std::unique_ptr<EntityPass>>(&element)) { |
| new_elements.push_back(subpass->get()->Clone()); |
| continue; |
| } |
| FML_UNREACHABLE(); |
| } |
| |
| auto pass = std::make_unique<EntityPass>(); |
| pass->SetElements(std::move(new_elements)); |
| return pass; |
| } |
| |
| void EntityPass::SetTransformation(Matrix xformation) { |
| xformation_ = std::move(xformation); |
| } |
| |
| void EntityPass::SetStencilDepth(size_t stencil_depth) { |
| stencil_depth_ = stencil_depth; |
| } |
| |
| void EntityPass::SetBlendMode(Entity::BlendMode blend_mode) { |
| blend_mode_ = blend_mode; |
| } |
| |
| } // namespace impeller |