#include <content_context.h>

Public Types
enum class	StencilMode : uint8_t { kIgnore , kStencilNonZeroFill , kStencilEvenOddFill , kCoverCompare , kCoverCompareInverted , kOverdrawPreventionIncrement , kOverdrawPreventionRestore }

Public Member Functions
constexpr uint64_t	ToKey () const

void	ApplyToPipelineDescriptor (PipelineDescriptor &desc) const

Public Attributes
SampleCount	sample_count = SampleCount::kCount1

BlendMode	blend_mode = BlendMode::kSourceOver

CompareFunction	depth_compare = CompareFunction::kAlways

StencilMode	stencil_mode = ContentContextOptions::StencilMode::kIgnore

PrimitiveType	primitive_type = PrimitiveType::kTriangle

PixelFormat	color_attachment_pixel_format = PixelFormat::kUnknown

bool	has_depth_stencil_attachments = true

bool	depth_write_enabled = false

bool	wireframe = false

bool	is_for_rrect_blur_clear = false

Detailed Description

Pipeline state configuration.

Each unique combination of these options requires a different pipeline state object to be built. This struct is used as a key for the per-pipeline variant cache.

When adding fields to this key, reliant features should take care to limit the combinatorical explosion of variations. A sufficiently complicated Flutter application may easily require building hundreds of PSOs in total, but they shouldn't require e.g. 10s of thousands.

Definition at line 279 of file content_context.h.

Member Enumeration Documentation

◆ StencilMode

enum impeller::ContentContextOptions::StencilMode : uint8_t

strong

Enumerator
kIgnore	Turn the stencil test off. Used when drawing without stencil-then-cover or overdraw prevention.
kStencilNonZeroFill	Draw the stencil for the NonZero fill path rule. The stencil ref should always be 0 on commands using this mode.
kStencilEvenOddFill	Draw the stencil for the EvenOdd fill path rule. The stencil ref should always be 0 on commands using this mode.
kCoverCompare	Used for draw calls which fill in the stenciled area. Intended to be used after `kStencilNonZeroFill` or `kStencilEvenOddFill` is used to set up the stencil buffer. Also cleans up the stencil buffer by resetting everything to zero. The stencil ref should always be 0 on commands using this mode.
kCoverCompareInverted	The opposite of `kCoverCompare`. Used for draw calls which fill in the non-stenciled area (intersection clips). Intended to be used after `kStencilNonZeroFill` or `kStencilEvenOddFill` is used to set up the stencil buffer. Also cleans up the stencil buffer by resetting everything to zero. The stencil ref should always be 0 on commands using this mode.
kOverdrawPreventionIncrement	For each fragment, increment the stencil value if it's currently zero. Discard fragments when the value is non-zero. This prevents self-overlapping strokes from drawing over themselves. Note that this is done for rendering correctness, not performance. If a stroke is drawn with a backdrop-reliant blend and self-intersects, then the intersected geometry will render incorrectly when overdrawn because we don't adjust the geometry prevent self-intersection. The stencil ref should always be 0 on commands using this mode.
kOverdrawPreventionRestore	Reset the stencil to a new maximum value specified by the ref (currently always 0). The stencil ref should always be 0 on commands using this mode.

Definition at line 280 of file content_context.h.

                          : uint8_t {
     /// Turn the stencil test off. Used when drawing without stencil-then-cover
     /// or overdraw prevention.
     kIgnore,
  
     // Operations used for stencil-then-cover.
  
     /// Draw the stencil for the NonZero fill path rule.
     ///
     /// The stencil ref should always be 0 on commands using this mode.
     kStencilNonZeroFill,
     /// Draw the stencil for the EvenOdd fill path rule.
     ///
     /// The stencil ref should always be 0 on commands using this mode.
     kStencilEvenOddFill,
     /// Used for draw calls which fill in the stenciled area. Intended to be
     /// used after `kStencilNonZeroFill` or `kStencilEvenOddFill` is used to set
     /// up the stencil buffer. Also cleans up the stencil buffer by resetting
     /// everything to zero.
     ///
     /// The stencil ref should always be 0 on commands using this mode.
     kCoverCompare,
     /// The opposite of `kCoverCompare`. Used for draw calls which fill in the
     /// non-stenciled area (intersection clips). Intended to be used after
     /// `kStencilNonZeroFill` or `kStencilEvenOddFill` is used to set up the
     /// stencil buffer. Also cleans up the stencil buffer by resetting
     /// everything to zero.
     ///
     /// The stencil ref should always be 0 on commands using this mode.
     kCoverCompareInverted,
  
     // Operations used for the "overdraw prevention" mechanism. This is used for
     // drawing strokes.
  
     /// For each fragment, increment the stencil value if it's currently zero.
     /// Discard fragments when the value is non-zero. This prevents
     /// self-overlapping strokes from drawing over themselves.
     ///
     /// Note that this is done for rendering correctness, not performance. If a
     /// stroke is drawn with a backdrop-reliant blend and self-intersects, then
     /// the intersected geometry will render incorrectly when overdrawn because
     /// we don't adjust the geometry prevent self-intersection.
     ///
     /// The stencil ref should always be 0 on commands using this mode.
     kOverdrawPreventionIncrement,
     /// Reset the stencil to a new maximum value specified by the ref (currently
     /// always 0).
     ///
     /// The stencil ref should always be 0 on commands using this mode.
     kOverdrawPreventionRestore,
   };

Member Function Documentation

◆ ApplyToPipelineDescriptor()

void impeller::ContentContextOptions::ApplyToPipelineDescriptor ( PipelineDescriptor & desc ) const

Definition at line 27 of file content_context.cc.

                                     {
   auto pipeline_blend = blend_mode;
   if (blend_mode > Entity::kLastPipelineBlendMode) {
     VALIDATION_LOG << "Cannot use blend mode " << static_cast<int>(blend_mode)
                    << " as a pipeline blend.";
     pipeline_blend = BlendMode::kSourceOver;
   }
  
   desc.SetSampleCount(sample_count);
  
   ColorAttachmentDescriptor color0 = *desc.GetColorAttachmentDescriptor(0u);
   color0.format = color_attachment_pixel_format;
   color0.alpha_blend_op = BlendOperation::kAdd;
   color0.color_blend_op = BlendOperation::kAdd;
   color0.write_mask = ColorWriteMaskBits::kAll;
  
   switch (pipeline_blend) {
     case BlendMode::kClear:
       if (is_for_rrect_blur_clear) {
         color0.alpha_blend_op = BlendOperation::kReverseSubtract;
         color0.color_blend_op = BlendOperation::kReverseSubtract;
         color0.dst_alpha_blend_factor = BlendFactor::kOne;
         color0.dst_color_blend_factor = BlendFactor::kOne;
         color0.src_alpha_blend_factor = BlendFactor::kDestinationColor;
         color0.src_color_blend_factor = BlendFactor::kDestinationColor;
       } else {
         color0.dst_alpha_blend_factor = BlendFactor::kZero;
         color0.dst_color_blend_factor = BlendFactor::kZero;
         color0.src_alpha_blend_factor = BlendFactor::kZero;
         color0.src_color_blend_factor = BlendFactor::kZero;
       }
       break;
     case BlendMode::kSource:
       color0.blending_enabled = false;
       color0.dst_alpha_blend_factor = BlendFactor::kZero;
       color0.dst_color_blend_factor = BlendFactor::kZero;
       color0.src_alpha_blend_factor = BlendFactor::kOne;
       color0.src_color_blend_factor = BlendFactor::kOne;
       break;
     case BlendMode::kDestination:
       color0.dst_alpha_blend_factor = BlendFactor::kOne;
       color0.dst_color_blend_factor = BlendFactor::kOne;
       color0.src_alpha_blend_factor = BlendFactor::kZero;
       color0.src_color_blend_factor = BlendFactor::kZero;
       color0.write_mask = ColorWriteMaskBits::kNone;
       break;
     case BlendMode::kSourceOver:
       color0.dst_alpha_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.src_alpha_blend_factor = BlendFactor::kOne;
       color0.src_color_blend_factor = BlendFactor::kOne;
       break;
     case BlendMode::kDestinationOver:
       color0.dst_alpha_blend_factor = BlendFactor::kOne;
       color0.dst_color_blend_factor = BlendFactor::kOne;
       color0.src_alpha_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       color0.src_color_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       break;
     case BlendMode::kSourceIn:
       color0.dst_alpha_blend_factor = BlendFactor::kZero;
       color0.dst_color_blend_factor = BlendFactor::kZero;
       color0.src_alpha_blend_factor = BlendFactor::kDestinationAlpha;
       color0.src_color_blend_factor = BlendFactor::kDestinationAlpha;
       break;
     case BlendMode::kDestinationIn:
       color0.dst_alpha_blend_factor = BlendFactor::kSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kSourceAlpha;
       color0.src_alpha_blend_factor = BlendFactor::kZero;
       color0.src_color_blend_factor = BlendFactor::kZero;
       break;
     case BlendMode::kSourceOut:
       color0.dst_alpha_blend_factor = BlendFactor::kZero;
       color0.dst_color_blend_factor = BlendFactor::kZero;
       color0.src_alpha_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       color0.src_color_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       break;
     case BlendMode::kDestinationOut:
       color0.dst_alpha_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.src_alpha_blend_factor = BlendFactor::kZero;
       color0.src_color_blend_factor = BlendFactor::kZero;
       break;
     case BlendMode::kSourceATop:
       color0.dst_alpha_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.src_alpha_blend_factor = BlendFactor::kDestinationAlpha;
       color0.src_color_blend_factor = BlendFactor::kDestinationAlpha;
       break;
     case BlendMode::kDestinationATop:
       color0.dst_alpha_blend_factor = BlendFactor::kSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kSourceAlpha;
       color0.src_alpha_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       color0.src_color_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       break;
     case BlendMode::kXor:
       color0.dst_alpha_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kOneMinusSourceAlpha;
       color0.src_alpha_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       color0.src_color_blend_factor = BlendFactor::kOneMinusDestinationAlpha;
       break;
     case BlendMode::kPlus:
       color0.dst_alpha_blend_factor = BlendFactor::kOne;
       color0.dst_color_blend_factor = BlendFactor::kOne;
       color0.src_alpha_blend_factor = BlendFactor::kOne;
       color0.src_color_blend_factor = BlendFactor::kOne;
       break;
     case BlendMode::kModulate:
       color0.dst_alpha_blend_factor = BlendFactor::kSourceAlpha;
       color0.dst_color_blend_factor = BlendFactor::kSourceColor;
       color0.src_alpha_blend_factor = BlendFactor::kZero;
       color0.src_color_blend_factor = BlendFactor::kZero;
       break;
     default:
       FML_UNREACHABLE();
   }
   desc.SetColorAttachmentDescriptor(0u, color0);
  
   if (!has_depth_stencil_attachments) {
     desc.ClearDepthAttachment();
     desc.ClearStencilAttachments();
   }
  
   auto maybe_stencil = desc.GetFrontStencilAttachmentDescriptor();
   auto maybe_depth = desc.GetDepthStencilAttachmentDescriptor();
   FML_DCHECK(has_depth_stencil_attachments == maybe_depth.has_value())
       << "Depth attachment doesn't match expected pipeline state. "
          "has_depth_stencil_attachments="
       << has_depth_stencil_attachments;
   FML_DCHECK(has_depth_stencil_attachments == maybe_stencil.has_value())
       << "Stencil attachment doesn't match expected pipeline state. "
          "has_depth_stencil_attachments="
       << has_depth_stencil_attachments;
   if (maybe_stencil.has_value()) {
     StencilAttachmentDescriptor front_stencil = maybe_stencil.value();
     StencilAttachmentDescriptor back_stencil = front_stencil;
  
     switch (stencil_mode) {
       case StencilMode::kIgnore:
         front_stencil.stencil_compare = CompareFunction::kAlways;
         front_stencil.depth_stencil_pass = StencilOperation::kKeep;
         desc.SetStencilAttachmentDescriptors(front_stencil);
         break;
       case StencilMode::kStencilNonZeroFill:
         // The stencil ref should be 0 on commands that use this mode.
         front_stencil.stencil_compare = CompareFunction::kAlways;
         front_stencil.depth_stencil_pass = StencilOperation::kIncrementWrap;
         back_stencil.stencil_compare = CompareFunction::kAlways;
         back_stencil.depth_stencil_pass = StencilOperation::kDecrementWrap;
         desc.SetStencilAttachmentDescriptors(front_stencil, back_stencil);
         break;
       case StencilMode::kStencilEvenOddFill:
         // The stencil ref should be 0 on commands that use this mode.
         front_stencil.stencil_compare = CompareFunction::kEqual;
         front_stencil.depth_stencil_pass = StencilOperation::kIncrementWrap;
         front_stencil.stencil_failure = StencilOperation::kDecrementWrap;
         desc.SetStencilAttachmentDescriptors(front_stencil);
         break;
       case StencilMode::kCoverCompare:
         // The stencil ref should be 0 on commands that use this mode.
         front_stencil.stencil_compare = CompareFunction::kNotEqual;
         front_stencil.depth_stencil_pass =
             StencilOperation::kSetToReferenceValue;
         desc.SetStencilAttachmentDescriptors(front_stencil);
         break;
       case StencilMode::kCoverCompareInverted:
         // The stencil ref should be 0 on commands that use this mode.
         front_stencil.stencil_compare = CompareFunction::kEqual;
         front_stencil.stencil_failure = StencilOperation::kSetToReferenceValue;
         desc.SetStencilAttachmentDescriptors(front_stencil);
         break;
       case StencilMode::kOverdrawPreventionIncrement:
         front_stencil.stencil_compare = CompareFunction::kEqual;
         front_stencil.depth_stencil_pass = StencilOperation::kIncrementClamp;
         desc.SetStencilAttachmentDescriptors(front_stencil);
         break;
       case StencilMode::kOverdrawPreventionRestore:
         front_stencil.stencil_compare = CompareFunction::kLess;
         front_stencil.depth_stencil_pass =
             StencilOperation::kSetToReferenceValue;
         desc.SetStencilAttachmentDescriptors(front_stencil);
         break;
     }
   }
   if (maybe_depth.has_value()) {
     DepthAttachmentDescriptor depth = maybe_depth.value();
     depth.depth_write_enabled = depth_write_enabled;
     depth.depth_compare = depth_compare;
     desc.SetDepthStencilAttachmentDescriptor(depth);
   }
  
   desc.SetPrimitiveType(primitive_type);
  
   desc.SetPolygonMode(wireframe ? PolygonMode::kLine : PolygonMode::kFill);
 }

◆ ToKey()

constexpr uint64_t impeller::ContentContextOptions::ToKey ( ) const

inlineconstexpr

Definition at line 343 of file content_context.h.

                                    {
     static_assert(sizeof(sample_count) == 1);
     static_assert(sizeof(blend_mode) == 1);
     static_assert(sizeof(sample_count) == 1);
     static_assert(sizeof(depth_compare) == 1);
     static_assert(sizeof(stencil_mode) == 1);
     static_assert(sizeof(primitive_type) == 1);
     static_assert(sizeof(color_attachment_pixel_format) == 1);
  
     return (is_for_rrect_blur_clear ? 1llu : 0llu) << 0 |
            (wireframe ? 1llu : 0llu) << 1 |
            (has_depth_stencil_attachments ? 1llu : 0llu) << 2 |
            (depth_write_enabled ? 1llu : 0llu) << 3 |
            // enums
            static_cast<uint64_t>(color_attachment_pixel_format) << 8 |
            static_cast<uint64_t>(primitive_type) << 16 |
            static_cast<uint64_t>(stencil_mode) << 24 |
            static_cast<uint64_t>(depth_compare) << 32 |
            static_cast<uint64_t>(blend_mode) << 40 |
            static_cast<uint64_t>(sample_count) << 48;
   }