impeller::EntityPassTarget Class Reference

#include <entity_pass_target.h>

Public Member Functions
	EntityPassTarget (const RenderTarget &render_target, bool supports_read_from_resolve)
std::shared_ptr< Texture >	Flip (Allocator &allocator)
	Flips the backdrop and returns a readable texture that can be bound/sampled to restore the previous pass. More...
const RenderTarget &	GetRenderTarget () const
bool	IsValid () const

Detailed Description

Definition at line 14 of file entity_pass_target.h.

Constructor & Destructor Documentation

EntityPassTarget()

impeller::EntityPassTarget::EntityPassTarget ( const RenderTarget &  render_target, bool  supports_read_from_resolve  )

explicit

Definition at line 13 of file entity_pass_target.cc.

    : target_(render_target),
      supports_read_from_resolve_(supports_read_from_resolve) {}

Member Function Documentation

Flip()

std::shared_ptr< Texture > impeller::EntityPassTarget::Flip

(

Allocator &

allocator

)

Flips the backdrop and returns a readable texture that can be bound/sampled to restore the previous pass.

After this method is called, a new RenderPass that attaches the result of GetRenderTarget is guaranteed to be able to read the previous pass's backdrop texture (which is returned by this method).

Definition at line 18 of file entity_pass_target.cc.

                                                                  {
  auto color0 = target_.GetColorAttachments().find(0)->second;
  if (!color0.resolve_texture) {
    VALIDATION_LOG << "EntityPassTarget Flip should never be called for a "
                      "non-MSAA target.";
    // ...because there is never a circumstance where doing so would be
    // necessary. Unlike MSAA passes, non-MSAA passes can be trivially loaded
    // with `LoadAction::kLoad`.
    return color0.texture;
  }
 
  if (supports_read_from_resolve_) {
    // Just return the current resolve texture, which is safe to read in the
    // next render pass that'll resolve to `target_`.
    //
    // Note that this can only be done when MSAA is being used.
    return color0.resolve_texture;
  }
 
  if (!secondary_color_texture_) {
    // The second texture is allocated lazily to avoid unused allocations.
    TextureDescriptor new_descriptor =
        color0.resolve_texture->GetTextureDescriptor();
    secondary_color_texture_ = allocator.CreateTexture(new_descriptor);
 
    if (!secondary_color_texture_) {
      return nullptr;
    }
  }
 
  std::swap(color0.resolve_texture, secondary_color_texture_);
 
  target_.SetColorAttachment(color0, 0);
 
  // Return the previous backdrop texture, which is safe to read in the next
  // render pass that attaches `target_`.
  return secondary_color_texture_;
}

References impeller::Allocator::CreateTexture(), impeller::RenderTarget::GetColorAttachments(), impeller::RenderTarget::SetColorAttachment(), and VALIDATION_LOG.

Referenced by impeller::InlinePassContext::GetRenderPass().

GetRenderTarget()

const RenderTarget & impeller::EntityPassTarget::GetRenderTarget

(

)

const

Definition at line 57 of file entity_pass_target.cc.

                                                            {
  return target_;
}

Referenced by impeller::InlinePassContext::GetRenderPass(), and impeller::InlinePassContext::GetTexture().

IsValid()

bool impeller::EntityPassTarget::IsValid

(

)

const

Definition at line 61 of file entity_pass_target.cc.

                                     {
  return target_.IsValid();
}

References impeller::RenderTarget::IsValid().

Referenced by impeller::InlinePassContext::IsValid().

---

The documentation for this class was generated from the following files:

• impeller/entity/entity_pass_target.h
• impeller/entity/entity_pass_target.cc