blob: 832dfe82734040aa3a7e5c36ecc6dcdb83c54cc8 [file] [log] [blame]
// 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 <memory>
#include <variant>
#include "flutter/fml/logging.h"
#include "flutter/fml/macros.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/entity/inline_pass_context.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) {
reads_from_pass_texture_ = 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(
std::optional<Rect> coverage_crop) 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();
if (coverage.has_value() && coverage_crop.has_value()) {
coverage = coverage->Intersection(coverage_crop.value());
}
} else if (auto subpass =
std::get_if<std::unique_ptr<EntityPass>>(&element)) {
coverage = GetSubpassCoverage(*subpass->get(), coverage_crop);
} 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,
std::optional<Rect> coverage_clip) const {
auto entities_coverage = subpass.GetElementsCoverage(coverage_clip);
// 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 ||
pass->backdrop_filter_proc_.has_value()) {
reads_from_pass_texture_ = 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 (reads_from_pass_texture_) {
auto offscreen_target = RenderTarget::CreateOffscreen(
*renderer.GetContext(), render_target.GetRenderTargetSize(),
"EntityPass", //
StorageMode::kDevicePrivate, LoadAction::kClear, StoreAction::kStore,
StorageMode::kDevicePrivate, LoadAction::kClear, StoreAction::kStore);
if (!OnRender(renderer, offscreen_target.GetRenderTargetSize(),
offscreen_target, Point(), Point(), 0)) {
return false;
}
auto command_buffer = renderer.GetContext()->CreateCommandBuffer();
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(offscreen_target.GetRenderTargetSize());
auto contents = TextureContents::MakeRect(size_rect);
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()) {
return false;
}
if (!command_buffer->SubmitCommands()) {
return false;
}
return true;
}
return OnRender(renderer, render_target.GetRenderTargetSize(), render_target,
Point(), Point(), 0);
}
EntityPass::EntityResult EntityPass::GetEntityForElement(
const EntityPass::Element& element,
ContentContext& renderer,
InlinePassContext& pass_context,
ISize root_pass_size,
Point position,
uint32_t pass_depth,
size_t stencil_depth_floor) const {
Entity element_entity;
//--------------------------------------------------------------------------
/// Setup entity element.
///
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.
///
else if (const auto& subpass_ptr =
std::get_if<std::unique_ptr<EntityPass>>(&element)) {
auto subpass = subpass_ptr->get();
if (subpass->delegate_->CanElide()) {
return EntityPass::EntityResult::Skip();
}
if (subpass->delegate_->CanCollapseIntoParentPass() &&
!subpass->backdrop_filter_proc_.has_value()) {
// Directly render into the parent target and move on.
if (!subpass->OnRender(renderer, root_pass_size,
pass_context.GetRenderTarget(), position, position,
stencil_depth_floor)) {
return EntityPass::EntityResult::Failure();
}
return EntityPass::EntityResult::Skip();
}
std::shared_ptr<Contents> backdrop_contents = nullptr;
if (subpass->backdrop_filter_proc_.has_value()) {
auto texture = pass_context.GetTexture();
// Render the backdrop texture before any of the pass elements.
const auto& proc = subpass->backdrop_filter_proc_.value();
backdrop_contents = proc(FilterInput::Make(std::move(texture)));
// The subpass will need to read from the current pass texture when
// rendering the backdrop, so if there's an active pass, end it prior to
// rendering the subpass.
pass_context.EndPass();
}
auto subpass_coverage =
GetSubpassCoverage(*subpass, Rect::MakeSize(root_pass_size));
if (subpass->cover_whole_screen) {
subpass_coverage = Rect(
position, Size(pass_context.GetRenderTarget().GetRenderTargetSize()));
}
if (backdrop_contents) {
auto backdrop_coverage = backdrop_contents->GetCoverage(Entity{});
if (backdrop_coverage.has_value()) {
backdrop_coverage->origin += position;
if (subpass_coverage.has_value()) {
subpass_coverage = subpass_coverage->Union(backdrop_coverage.value());
} else {
subpass_coverage = backdrop_coverage;
}
}
}
if (subpass_coverage.has_value()) {
subpass_coverage =
subpass_coverage->Intersection(Rect::MakeSize(root_pass_size));
}
if (!subpass_coverage.has_value()) {
return EntityPass::EntityResult::Skip();
}
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.
return EntityPass::EntityResult::Skip();
}
RenderTarget subpass_target;
if (subpass->reads_from_pass_texture_) {
subpass_target = RenderTarget::CreateOffscreen(
*renderer.GetContext(), ISize::Ceil(subpass_coverage->size),
"EntityPass", StorageMode::kDevicePrivate, LoadAction::kClear,
StoreAction::kStore, StorageMode::kDevicePrivate, LoadAction::kClear,
StoreAction::kStore);
} else {
subpass_target = RenderTarget::CreateOffscreen(
*renderer.GetContext(), 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 EntityPass::EntityResult::Failure();
}
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 EntityPass::EntityResult::Failure();
}
// Stencil textures aren't shared between EntityPasses (as much of the
// time they are transient).
if (!subpass->OnRender(renderer, root_pass_size, subpass_target,
subpass_coverage->origin, position, ++pass_depth,
subpass->stencil_depth_, backdrop_contents)) {
return EntityPass::EntityResult::Failure();
}
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();
}
return EntityPass::EntityResult::Success(element_entity);
}
bool EntityPass::OnRender(ContentContext& renderer,
ISize root_pass_size,
RenderTarget render_target,
Point position,
Point parent_position,
uint32_t pass_depth,
size_t stencil_depth_floor,
std::shared_ptr<Contents> backdrop_contents) const {
TRACE_EVENT0("impeller", "EntityPass::OnRender");
auto context = renderer.GetContext();
InlinePassContext pass_context(context, render_target);
if (!pass_context.IsValid()) {
return false;
}
auto render_element = [&stencil_depth_floor, &pass_context, &pass_depth,
&renderer](Entity& element_entity) {
element_entity.SetStencilDepth(element_entity.GetStencilDepth() -
stencil_depth_floor);
auto pass = pass_context.GetRenderPass(pass_depth);
if (!pass) {
return false;
}
if (!element_entity.ShouldRender(pass->GetRenderTargetSize())) {
return true; // Nothing to render.
}
if (!element_entity.Render(renderer, *pass)) {
return false;
}
return true;
};
if (backdrop_filter_proc_.has_value()) {
if (!backdrop_contents) {
return false;
}
Entity backdrop_entity;
backdrop_entity.SetContents(std::move(backdrop_contents));
backdrop_entity.SetTransformation(
Matrix::MakeTranslation(Vector3(parent_position - position)));
backdrop_entity.SetStencilDepth(stencil_depth_floor);
render_element(backdrop_entity);
}
for (const auto& element : elements_) {
EntityResult result =
GetEntityForElement(element, renderer, pass_context, root_pass_size,
position, pass_depth, stencil_depth_floor);
switch (result.status) {
case EntityResult::kSuccess:
break;
case EntityResult::kFailure:
return false;
case EntityResult::kSkip:
continue;
};
//--------------------------------------------------------------------------
/// Setup advanced blends.
///
if (result.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 (!pass_context.EndPass()) {
return false;
}
// Amend an advanced blend filter to the contents, attaching the pass
// texture.
auto texture = pass_context.GetTexture();
if (!texture) {
return false;
}
FilterInput::Vector inputs = {
FilterInput::Make(result.entity.GetContents()),
FilterInput::Make(texture,
result.entity.GetTransformation().Invert())};
auto contents =
FilterContents::MakeBlend(result.entity.GetBlendMode(), inputs);
contents->SetCoverageCrop(result.entity.GetCoverage());
result.entity.SetContents(std::move(contents));
result.entity.SetBlendMode(Entity::BlendMode::kSourceOver);
}
//--------------------------------------------------------------------------
/// Render the Element.
///
if (!render_element(result.entity)) {
return false;
}
}
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;
cover_whole_screen = Entity::BlendModeShouldCoverWholeScreen(blend_mode);
}
void EntityPass::SetBackdropFilter(std::optional<BackdropFilterProc> proc) {
backdrop_filter_proc_ = proc;
if (superpass_) {
superpass_->reads_from_pass_texture_ = true;
}
}
} // namespace impeller