#include <draw_order_resolver.h>

Public Types
using	ElementRefs = std::vector< size_t >

Public Member Functions
	DrawOrderResolver ()

void	AddElement (size_t element_index, bool is_opaque)

void	PushClip (size_t element_index)

void	PopClip ()

void	Flush ()

ElementRefs	GetSortedDraws (size_t opaque_skip_count, size_t translucent_skip_count) const
	Returns the sorted draws for the current draw order layer. This should only be called after all recording has finished.

Detailed Description

Helper that records draw indices in painter's order and sorts the draws into an optimized order based on translucency and clips.

Definition at line 15 of file draw_order_resolver.h.

Member Typedef Documentation

◆ ElementRefs

using impeller::DrawOrderResolver::ElementRefs = std::vector<size_t>

Definition at line 17 of file draw_order_resolver.h.

Constructor & Destructor Documentation

◆ DrawOrderResolver()

impeller::DrawOrderResolver::DrawOrderResolver ( )

Definition at line 12 of file draw_order_resolver.cc.

12: draw_order_layers_({{}}) {};

Member Function Documentation

◆ AddElement()

void impeller::DrawOrderResolver::AddElement	(	size_t	element_index,
		bool	is_opaque
	)

Definition at line 14 of file draw_order_resolver.cc.

                                                                       {
  DrawOrderLayer& layer = draw_order_layers_.back();
  if (is_opaque) {
    layer.opaque_elements.push_back(element_index);
  } else {
    layer.dependent_elements.push_back(element_index);
  }
}

Referenced by impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST().

◆ Flush()

void impeller::DrawOrderResolver::Flush ( )

Definition at line 44 of file draw_order_resolver.cc.

                              {
  FML_DCHECK(draw_order_layers_.size() >= 1u);
 
  size_t layer_count = draw_order_layers_.size();
 
  // Pop all clip layers.
  while (draw_order_layers_.size() > 1u) {
    PopClip();
  }
 
  // Move the root layer items into the sorted list.
  DrawOrderLayer& layer = draw_order_layers_.back();
  if (!first_root_flush_.has_value()) {
    // Record the first flush.
    first_root_flush_ = std::move(layer);
    layer = {};
  } else {
    // Write subsequent flushes into the sorted root list.
    layer.WriteCombinedDraws(sorted_elements_, 0, 0);
    layer.opaque_elements.clear();
    layer.dependent_elements.clear();
  }
 
  // Refill with empty layers.
  draw_order_layers_.resize(layer_count);
}

References FML_DCHECK, and PopClip().

Referenced by impeller::testing::TEST().

◆ GetSortedDraws()

DrawOrderResolver::ElementRefs impeller::DrawOrderResolver::GetSortedDraws	(	size_t	opaque_skip_count,
		size_t	translucent_skip_count
	)		const

Returns the sorted draws for the current draw order layer. This should only be called after all recording has finished.

Parameters

[in]	opaque_skip_count	The number of opaque elements to skip when appending the combined elements. This is used for the "clear color" optimization.
[in]	translucent_skip_count	The number of translucent elements to skip when appending the combined elements. This is used for the "clear color" optimization.

Definition at line 71 of file draw_order_resolver.cc.

                                         {
  FML_DCHECK(draw_order_layers_.size() == 1u)
      << "Attempted to get sorted draws before all clips were popped.";
 
  ElementRefs sorted_elements;
  sorted_elements.reserve(
      (first_root_flush_.has_value()
           ? first_root_flush_->opaque_elements.size() +
                 first_root_flush_->dependent_elements.size()
           : 0u) +
      sorted_elements_.size() +
      draw_order_layers_.back().opaque_elements.size() +
      draw_order_layers_.back().dependent_elements.size());
 
  // Write all flushed items.
  if (first_root_flush_.has_value()) {
    first_root_flush_->WriteCombinedDraws(sorted_elements, opaque_skip_count,
                                          translucent_skip_count);
  }
  sorted_elements.insert(sorted_elements.end(), sorted_elements_.begin(),
                         sorted_elements_.end());
 
  // Write any remaining non-flushed items.
  draw_order_layers_.back().WriteCombinedDraws(
      sorted_elements, first_root_flush_.has_value() ? 0 : opaque_skip_count,
      first_root_flush_.has_value() ? 0 : translucent_skip_count);
 
  return sorted_elements;
}

References FML_DCHECK.

Referenced by impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST().

◆ PopClip()

void impeller::DrawOrderResolver::PopClip ( )

Definition at line 27 of file draw_order_resolver.cc.

                                {
  if (draw_order_layers_.size() == 1u) {
    // This is likely recoverable, so don't assert.
    VALIDATION_LOG << "Attemped to pop the first draw order clip layer. This "
                      "may be a bug in `EntityPass`.";
    return;
  }
 
  DrawOrderLayer& layer = draw_order_layers_.back();
  DrawOrderLayer& parent_layer =
      draw_order_layers_[draw_order_layers_.size() - 2];
 
  layer.WriteCombinedDraws(parent_layer.dependent_elements, 0, 0);
 
  draw_order_layers_.pop_back();
}

References VALIDATION_LOG.

Referenced by Flush(), and impeller::testing::TEST().

◆ PushClip()

void impeller::DrawOrderResolver::PushClip ( size_t element_index )

Definition at line 22 of file draw_order_resolver.cc.

                                                     {
  draw_order_layers_.back().dependent_elements.push_back(element_index);
  draw_order_layers_.push_back({});
};