GrVkRenderPass Class Reference

#include <GrVkRenderPass.h>

Inheritance diagram for GrVkRenderPass:

Classes
struct	AttachmentsDescriptor
struct	LoadStoreOps

Public Types
enum	AttachmentFlags : uint32_t { kColor_AttachmentFlag = 0x1 , kStencil_AttachmentFlag = 0x2 , kResolve_AttachmentFlag = 0x4 , kExternal_AttachmentFlag = 0x8 }
enum class	SelfDependencyFlags { kNone = 0 , kForInputAttachment = 1 << 0 , kForNonCoherentAdvBlend = 1 << 1 }
enum class	LoadFromResolve { kNo , kLoad }

Public Member Functions
	GrVkRenderPass (const GrVkGpu *gpu, VkRenderPass renderPass, uint32_t colorAttachmentIndex)
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (SelfDependencyFlags)
bool	colorAttachmentIndex (uint32_t *index) const
bool	stencilAttachmentIndex (uint32_t *index) const
bool	hasStencilAttachment () const
bool	hasResolveAttachment () const
SelfDependencyFlags	selfDependencyFlags () const
LoadFromResolve	loadFromResolve () const
bool	isCompatible (GrVkRenderTarget *target, SelfDependencyFlags selfDepFlags, LoadFromResolve) const
bool	isCompatible (const GrVkRenderPass &renderPass) const
bool	isCompatible (const AttachmentsDescriptor &, const AttachmentFlags &, SelfDependencyFlags selfDepFlags, LoadFromResolve) const
bool	isCompatibleExternalRP (VkRenderPass) const
	SkDEBUGCODE (bool isExternal() const { return fAttachmentFlags &kExternal_AttachmentFlag;}) bool equalLoadStoreOps(const LoadStoreOps &colorOps
VkRenderPass	vkRenderPass () const
const VkExtent2D &	granularity () const
uint32_t	clearValueCount () const
void	genKey (skgpu::KeyBuilder *) const
Public Member Functions inherited from GrVkManagedResource
	GrVkManagedResource (const GrVkGpu *gpu)
Public Member Functions inherited from GrManagedResource
	GrManagedResource ()
virtual	~GrManagedResource ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static GrVkRenderPass *	CreateSimple (GrVkGpu *, AttachmentsDescriptor *, AttachmentFlags, SelfDependencyFlags selfDepFlags, LoadFromResolve)
static GrVkRenderPass *	Create (GrVkGpu *, const GrVkRenderPass &compatibleRenderPass, const LoadStoreOps &colorOp, const LoadStoreOps &resolveOp, const LoadStoreOps &stencilOp)
static void	GenKey (skgpu::KeyBuilder *, AttachmentFlags, const AttachmentsDescriptor &, SelfDependencyFlags selfDepFlags, LoadFromResolve, uint64_t externalRenderPass)

Public Attributes
const LoadStoreOps &	resolveOps
const LoadStoreOps const LoadStoreOps &stencilOps	const

Additional Inherited Members
Protected Attributes inherited from GrVkManagedResource
const GrVkGpu *	fGpu

Detailed Description

Definition at line 24 of file GrVkRenderPass.h.

Member Enumeration Documentation

AttachmentFlags

enum GrVkRenderPass::AttachmentFlags : uint32_t

Enumerator
kColor_AttachmentFlag
kStencil_AttachmentFlag
kResolve_AttachmentFlag
kExternal_AttachmentFlag

Definition at line 83 of file GrVkRenderPass.h.

                         : uint32_t {
        kColor_AttachmentFlag = 0x1,
        kStencil_AttachmentFlag = 0x2,
        kResolve_AttachmentFlag = 0x4,
        // The external attachment flag signals that this render pass is imported from an external
        // client. Since we don't know every attachment on the render pass we don't set any of the
        // specific attachment flags when using external. However, the external render pass must
        // at least have a color attachment.
        kExternal_AttachmentFlag = 0x8,
    };

LoadFromResolve

enum class GrVkRenderPass::LoadFromResolve

strong

Enumerator
kNo
kLoad

Definition at line 102 of file GrVkRenderPass.h.

                               {
        kNo,
        kLoad,
    };

SelfDependencyFlags

enum class GrVkRenderPass::SelfDependencyFlags

strong

Enumerator
kNone
kForInputAttachment
kForNonCoherentAdvBlend

Definition at line 95 of file GrVkRenderPass.h.

                                   {
        kNone =                   0,
        kForInputAttachment =     1 << 0,
        kForNonCoherentAdvBlend = 1 << 1,
    };

Constructor & Destructor Documentation

GrVkRenderPass()

GrVkRenderPass::GrVkRenderPass ( const GrVkGpu *  gpu, VkRenderPass  renderPass, uint32_t  colorAttachmentIndex  )

inlineexplicit

Definition at line 45 of file GrVkRenderPass.h.

            : INHERITED(gpu)
            , fRenderPass(renderPass)
            , fAttachmentFlags(kExternal_AttachmentFlag)
            , fSelfDepFlags(SelfDependencyFlags::kNone)
            , fLoadFromResolve(LoadFromResolve::kNo)
            , fClearValueCount(0)
            , fColorAttachmentIndex(colorAttachmentIndex) {}

Member Function Documentation

clearValueCount()

uint32_t GrVkRenderPass::clearValueCount ( ) const

inline

Definition at line 158 of file GrVkRenderPass.h.

{ return fClearValueCount; }

colorAttachmentIndex()

bool GrVkRenderPass::colorAttachmentIndex

(

uint32_t *

index

)

const

Definition at line 344 of file GrVkRenderPass.cpp.

                                                               {
    *index = fColorAttachmentIndex;
    if ((fAttachmentFlags & kColor_AttachmentFlag) ||
        (fAttachmentFlags & kExternal_AttachmentFlag)) {
        return true;
    }
    return false;
}

Create()

GrVkRenderPass * GrVkRenderPass::Create ( GrVkGpu *  gpu, const GrVkRenderPass &  compatibleRenderPass, const LoadStoreOps &  colorOp, const LoadStoreOps &  resolveOp, const LoadStoreOps &  stencilOp  )

static

Definition at line 73 of file GrVkRenderPass.cpp.

                                                                      {
    AttachmentFlags attachmentFlags = compatibleRenderPass.fAttachmentFlags;
    AttachmentsDescriptor attachmentsDescriptor = compatibleRenderPass.fAttachmentsDescriptor;
    SelfDependencyFlags selfDepFlags = compatibleRenderPass.fSelfDepFlags;
    LoadFromResolve loadFromResolve = compatibleRenderPass.fLoadFromResolve;
    return Create(gpu, attachmentFlags, &attachmentsDescriptor, colorOp, resolveOp, stencilOp,
                  selfDepFlags, loadFromResolve);
}

CreateSimple()

GrVkRenderPass * GrVkRenderPass::CreateSimple ( GrVkGpu *  gpu, AttachmentsDescriptor *  attachmentsDescriptor, AttachmentFlags  attachmentFlags, SelfDependencyFlags  selfDepFlags, LoadFromResolve  loadFromResolve  )

static

Definition at line 52 of file GrVkRenderPass.cpp.

                                                                              {
    static const GrVkRenderPass::LoadStoreOps kBasicLoadStoreOps(VK_ATTACHMENT_LOAD_OP_LOAD,
                                                                 VK_ATTACHMENT_STORE_OP_STORE);
    switch (loadFromResolve) {
        case LoadFromResolve::kNo:
            return Create(gpu, attachmentFlags, attachmentsDescriptor, kBasicLoadStoreOps,
                          kBasicLoadStoreOps, kBasicLoadStoreOps, selfDepFlags, loadFromResolve);
        case LoadFromResolve::kLoad: {
            static const GrVkRenderPass::LoadStoreOps kDiscardLoadStoreOps(
                    VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE);
            return Create(gpu, attachmentFlags, attachmentsDescriptor, kDiscardLoadStoreOps,
                          kBasicLoadStoreOps, kBasicLoadStoreOps, selfDepFlags, loadFromResolve);
        }
    }
    SkUNREACHABLE;
}

genKey()

void GrVkRenderPass::genKey

(

skgpu::KeyBuilder *

b

)

const

Definition at line 450 of file GrVkRenderPass.cpp.

                                                    {
    GenKey(b, fAttachmentFlags, fAttachmentsDescriptor, fSelfDepFlags,
           fLoadFromResolve, (uint64_t)fRenderPass);
}

GenKey()

void GrVkRenderPass::GenKey ( skgpu::KeyBuilder *  b, AttachmentFlags  attachmentFlags, const AttachmentsDescriptor &  attachmentsDescriptor, SelfDependencyFlags  selfDepFlags, LoadFromResolve  loadFromResolve, uint64_t  externalRenderPass  )

static

Definition at line 455 of file GrVkRenderPass.cpp.

                                                         {
    b->add32(attachmentFlags);
    if (attachmentFlags & kColor_AttachmentFlag) {
        b->add32(attachmentsDescriptor.fColor.fFormat);
        b->add32(attachmentsDescriptor.fColor.fSamples);
    }
    if (attachmentFlags & kResolve_AttachmentFlag) {
        b->add32(attachmentsDescriptor.fResolve.fFormat);
        b->add32(attachmentsDescriptor.fResolve.fSamples);
    }
    if (attachmentFlags & kStencil_AttachmentFlag) {
        b->add32(attachmentsDescriptor.fStencil.fFormat);
        b->add32(attachmentsDescriptor.fStencil.fSamples);
    }
 
    uint32_t extraFlags = (uint32_t)selfDepFlags;
    SkASSERT(extraFlags < (1 << 30));
    SkASSERT((uint32_t)loadFromResolve <= 2);
    extraFlags |= ((uint32_t)loadFromResolve << 30);
 
    b->add32(extraFlags);
 
    if (attachmentFlags & kExternal_AttachmentFlag) {
        SkASSERT(!(attachmentFlags & ~kExternal_AttachmentFlag));
        b->add32((uint32_t)(externalRenderPass & 0xFFFFFFFF));
        b->add32((uint32_t)(externalRenderPass>>32));
    }
}

GR_DECL_BITFIELD_CLASS_OPS_FRIENDS()

GrVkRenderPass::GR_DECL_BITFIELD_CLASS_OPS_FRIENDS

(

SelfDependencyFlags

)

granularity()

const VkExtent2D & GrVkRenderPass::granularity ( ) const

inline

Definition at line 154 of file GrVkRenderPass.h.

{ return fGranularity; }

hasResolveAttachment()

bool GrVkRenderPass::hasResolveAttachment ( ) const

inline

Definition at line 124 of file GrVkRenderPass.h.

{ return fAttachmentFlags & kResolve_AttachmentFlag; }

hasStencilAttachment()

bool GrVkRenderPass::hasStencilAttachment ( ) const

inline

Definition at line 123 of file GrVkRenderPass.h.

{ return fAttachmentFlags & kStencil_AttachmentFlag; }

isCompatible() [1/3]

bool GrVkRenderPass::isCompatible	(	const AttachmentsDescriptor &	desc,
		const AttachmentFlags &	flags,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)		const

Definition at line 366 of file GrVkRenderPass.cpp.

                                                                         {
    SkASSERT(!(fAttachmentFlags & kExternal_AttachmentFlag));
    if (flags != fAttachmentFlags) {
        return false;
    }
 
    if (fAttachmentFlags & kColor_AttachmentFlag) {
        if (!fAttachmentsDescriptor.fColor.isCompatible(desc.fColor)) {
            return false;
        }
    }
    if (fAttachmentFlags & kResolve_AttachmentFlag) {
        if (!fAttachmentsDescriptor.fResolve.isCompatible(desc.fResolve)) {
            return false;
        }
    }
    if (fAttachmentFlags & kStencil_AttachmentFlag) {
        if (!fAttachmentsDescriptor.fStencil.isCompatible(desc.fStencil)) {
            return false;
        }
    }
 
    if (fSelfDepFlags != selfDepFlags) {
        return false;
    }
 
    if (fLoadFromResolve != loadFromResolve) {
        return false;
    }
 
    return true;
}

isCompatible() [2/3]

bool GrVkRenderPass::isCompatible

(

const GrVkRenderPass &

renderPass

)

const

Definition at line 417 of file GrVkRenderPass.cpp.

                                                                        {
    SkASSERT(!(fAttachmentFlags & kExternal_AttachmentFlag));
    return this->isCompatible(renderPass.fAttachmentsDescriptor, renderPass.fAttachmentFlags,
                              renderPass.fSelfDepFlags, renderPass.fLoadFromResolve);
}

isCompatible() [3/3]

bool GrVkRenderPass::isCompatible	(	GrVkRenderTarget *	target,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)		const

Definition at line 402 of file GrVkRenderPass.cpp.

                                                                         {
    SkASSERT(!(fAttachmentFlags & kExternal_AttachmentFlag));
 
    AttachmentsDescriptor desc;
    AttachmentFlags flags;
    if (!target->getAttachmentsDescriptor(&desc, &flags, this->hasResolveAttachment(),
                                          this->hasStencilAttachment())) {
        return false;
    }
 
    return this->isCompatible(desc, flags, selfDepFlags, loadFromResolve);
}

isCompatibleExternalRP()

bool GrVkRenderPass::isCompatibleExternalRP

(

VkRenderPass

renderPass

)

const

Definition at line 423 of file GrVkRenderPass.cpp.

                                                                         {
    SkASSERT(fAttachmentFlags & kExternal_AttachmentFlag);
    return fRenderPass == renderPass;
}

loadFromResolve()

LoadFromResolve GrVkRenderPass::loadFromResolve ( ) const

inline

Definition at line 127 of file GrVkRenderPass.h.

{ return fLoadFromResolve; }

selfDependencyFlags()

SelfDependencyFlags GrVkRenderPass::selfDependencyFlags ( ) const

inline

Definition at line 126 of file GrVkRenderPass.h.

{ return fSelfDepFlags; }

SkDEBUGCODE()

GrVkRenderPass::SkDEBUGCODE

(

bool isExternal() const { return fAttachmentFlags &kExternal_AttachmentFlag;}

)

const &

stencilAttachmentIndex()

bool GrVkRenderPass::stencilAttachmentIndex

(

uint32_t *

index

)

const

Definition at line 355 of file GrVkRenderPass.cpp.

                                                                 {
    *index = 0;
    if (fAttachmentFlags & kColor_AttachmentFlag) {
        ++(*index);
    }
    if (fAttachmentFlags & kStencil_AttachmentFlag) {
        return true;
    }
    return false;
}

vkRenderPass()

VkRenderPass GrVkRenderPass::vkRenderPass ( ) const

inline

Definition at line 152 of file GrVkRenderPass.h.

{ return fRenderPass; }

Member Data Documentation

const

const LoadStoreOps const LoadStoreOps& stencilOps GrVkRenderPass::const

Definition at line 150 of file GrVkRenderPass.h.

resolveOps

const LoadStoreOps& GrVkRenderPass::resolveOps

Definition at line 149 of file GrVkRenderPass.h.

---

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

• third_party/skia/src/gpu/ganesh/vk/GrVkRenderPass.h
• third_party/skia/src/gpu/ganesh/vk/GrVkRenderPass.cpp