| // 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_clip_stack.h" | |
| #include "flutter/fml/logging.h" | |
| #include "impeller/entity/contents/clip_contents.h" | |
| namespace impeller { | |
| EntityPassClipStack::EntityPassClipStack(const Rect& initial_coverage_rect) { | |
| subpass_state_.push_back(SubpassState{ | |
| .clip_coverage = | |
| { | |
| {ClipCoverageLayer{ | |
| .coverage = initial_coverage_rect, | |
| .clip_height = 0, | |
| }}, | |
| }, | |
| }); | |
| } | |
| std::optional<Rect> EntityPassClipStack::CurrentClipCoverage() const { | |
| return subpass_state_.back().clip_coverage.back().coverage; | |
| } | |
| bool EntityPassClipStack::HasCoverage() const { | |
| return !subpass_state_.back().clip_coverage.empty(); | |
| } | |
| void EntityPassClipStack::PushSubpass(std::optional<Rect> subpass_coverage, | |
| size_t clip_height) { | |
| subpass_state_.push_back(SubpassState{ | |
| .clip_coverage = | |
| { | |
| ClipCoverageLayer{.coverage = subpass_coverage, | |
| .clip_height = clip_height}, | |
| }, | |
| }); | |
| next_replay_index_ = 0; | |
| } | |
| void EntityPassClipStack::PopSubpass() { | |
| subpass_state_.pop_back(); | |
| next_replay_index_ = subpass_state_.back().rendered_clip_entities.size(); | |
| } | |
| const std::vector<ClipCoverageLayer> | |
| EntityPassClipStack::GetClipCoverageLayers() const { | |
| return subpass_state_.back().clip_coverage; | |
| } | |
| EntityPassClipStack::ClipStateResult EntityPassClipStack::RecordRestore( | |
| Point global_pass_position, | |
| size_t restore_height) { | |
| ClipStateResult result = {.should_render = false, .clip_did_change = false}; | |
| auto& subpass_state = GetCurrentSubpassState(); | |
| if (subpass_state.clip_coverage.back().clip_height <= restore_height) { | |
| // Drop clip restores that will do nothing. | |
| return result; | |
| } | |
| auto restoration_index = | |
| restore_height - subpass_state.clip_coverage.front().clip_height; | |
| FML_DCHECK(restoration_index < subpass_state.clip_coverage.size()); | |
| // We only need to restore the area that covers the coverage of the | |
| // clip rect at target height + 1. | |
| std::optional<Rect> restore_coverage = | |
| (restoration_index + 1 < subpass_state.clip_coverage.size()) | |
| ? subpass_state.clip_coverage[restoration_index + 1].coverage | |
| : std::nullopt; | |
| if (restore_coverage.has_value()) { | |
| // Make the coverage rectangle relative to the current pass. | |
| restore_coverage = restore_coverage->Shift(-global_pass_position); | |
| } | |
| subpass_state.clip_coverage.resize(restoration_index + 1); | |
| result.clip_did_change = true; | |
| if (subpass_state.clip_coverage.back().coverage.has_value()) { | |
| FML_DCHECK(next_replay_index_ <= | |
| subpass_state.rendered_clip_entities.size()); | |
| if (!subpass_state.rendered_clip_entities.empty()) { | |
| subpass_state.rendered_clip_entities.pop_back(); | |
| if (next_replay_index_ > subpass_state.rendered_clip_entities.size()) { | |
| next_replay_index_ = subpass_state.rendered_clip_entities.size(); | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| EntityPassClipStack::ClipStateResult EntityPassClipStack::RecordClip( | |
| const ClipContents& clip_contents, | |
| Matrix transform, | |
| Point global_pass_position, | |
| uint32_t clip_depth, | |
| size_t clip_height_floor, | |
| bool is_aa) { | |
| ClipStateResult result = {.should_render = false, .clip_did_change = false}; | |
| std::optional<Rect> maybe_clip_coverage = CurrentClipCoverage(); | |
| // Running this append op won't impact the clip buffer because the | |
| // whole screen is already being clipped, so skip it. | |
| if (!maybe_clip_coverage.has_value()) { | |
| return result; | |
| } | |
| auto current_clip_coverage = maybe_clip_coverage.value(); | |
| // Entity transforms are relative to the current pass position, so we need | |
| // to check clip coverage in the same space. | |
| current_clip_coverage = current_clip_coverage.Shift(-global_pass_position); | |
| ClipCoverage clip_coverage = | |
| clip_contents.GetClipCoverage(current_clip_coverage); | |
| if (clip_coverage.coverage.has_value()) { | |
| clip_coverage.coverage = | |
| clip_coverage.coverage->Shift(global_pass_position); | |
| } | |
| SubpassState& subpass_state = GetCurrentSubpassState(); | |
| // Compute the previous clip height. | |
| size_t previous_clip_height = 0; | |
| if (!subpass_state.clip_coverage.empty()) { | |
| previous_clip_height = subpass_state.clip_coverage.back().clip_height; | |
| } else { | |
| // If there is no clip coverage, then the previous clip height is the | |
| // clip height floor. | |
| previous_clip_height = clip_height_floor; | |
| } | |
| // If the new clip coverage is bigger than the existing coverage for | |
| // intersect clips, we do not need to change the clip region. | |
| if (!clip_coverage.is_difference_or_non_square && | |
| clip_coverage.coverage.has_value() && | |
| clip_coverage.coverage.value().Contains(current_clip_coverage)) { | |
| subpass_state.clip_coverage.push_back(ClipCoverageLayer{ | |
| .coverage = current_clip_coverage, // | |
| .clip_height = previous_clip_height + 1 // | |
| }); | |
| return result; | |
| } | |
| // If the clip is an axis aligned rect and either is_aa is false or | |
| // the clip is very nearly integral, then the depth write can be | |
| // skipped for intersect clips. Since we use 4x MSAA, anything within | |
| // < ~0.125 of an integral value in either axis can be treated as | |
| // approximately the same as an integral value. | |
| bool should_render = true; | |
| std::optional<Rect> coverage_value = clip_coverage.coverage; | |
| if (!clip_coverage.is_difference_or_non_square && | |
| coverage_value.has_value()) { | |
| const Rect& coverage = coverage_value.value(); | |
| constexpr Scalar threshold = 0.124; | |
| if (!is_aa || | |
| (std::abs(std::round(coverage.GetLeft()) - coverage.GetLeft()) <= | |
| threshold && | |
| std::abs(std::round(coverage.GetTop()) - coverage.GetTop()) <= | |
| threshold && | |
| std::abs(std::round(coverage.GetRight()) - coverage.GetRight()) <= | |
| threshold && | |
| std::abs(std::round(coverage.GetBottom()) - coverage.GetBottom()) <= | |
| threshold)) { | |
| coverage_value = Rect::Round(clip_coverage.coverage.value()); | |
| should_render = false; | |
| } | |
| } | |
| subpass_state.clip_coverage.push_back(ClipCoverageLayer{ | |
| .coverage = coverage_value, // | |
| .clip_height = previous_clip_height + 1 // | |
| }); | |
| result.clip_did_change = true; | |
| result.should_render = should_render; | |
| FML_DCHECK(subpass_state.clip_coverage.back().clip_height == | |
| subpass_state.clip_coverage.front().clip_height + | |
| subpass_state.clip_coverage.size() - 1); | |
| FML_DCHECK(next_replay_index_ == subpass_state.rendered_clip_entities.size()) | |
| << "Not all clips have been replayed before appending new clip."; | |
| subpass_state.rendered_clip_entities.push_back(ReplayResult{ | |
| .clip_contents = clip_contents, // | |
| .transform = transform, // | |
| .clip_coverage = coverage_value, // | |
| .clip_depth = clip_depth // | |
| }); | |
| next_replay_index_++; | |
| return result; | |
| } | |
| EntityPassClipStack::SubpassState& | |
| EntityPassClipStack::GetCurrentSubpassState() { | |
| return subpass_state_.back(); | |
| } | |
| const std::vector<EntityPassClipStack::ReplayResult>& | |
| EntityPassClipStack::GetReplayEntities() const { | |
| return subpass_state_.back().rendered_clip_entities; | |
| } | |
| void EntityPassClipStack::ActivateClipReplay() { | |
| next_replay_index_ = 0; | |
| } | |
| const EntityPassClipStack::ReplayResult* | |
| EntityPassClipStack::GetNextReplayResult(size_t current_clip_depth) { | |
| if (next_replay_index_ >= | |
| subpass_state_.back().rendered_clip_entities.size()) { | |
| // No clips need to be replayed. | |
| return nullptr; | |
| } | |
| ReplayResult* next_replay = | |
| &subpass_state_.back().rendered_clip_entities[next_replay_index_]; | |
| if (next_replay->clip_depth < current_clip_depth) { | |
| // The next replay clip doesn't affect the current entity, so don't replay | |
| // it yet. | |
| return nullptr; | |
| } | |
| next_replay_index_++; | |
| return next_replay; | |
| } | |
| } // namespace impeller |