#include <GrVkImage.h>

Inheritance diagram for GrVkImage:

Classes
struct	ImageDesc

Public Types
typedef void *	ReleaseCtx

typedef void(*	ReleaseProc) (ReleaseCtx)

Public Types inherited from GrAttachment
enum class	UsageFlags : uint8_t { kStencilAttachment = 0x1 , kColorAttachment = 0x2 , kTexture = 0x4 }

Public Types inherited from GrSurface
typedef void *	ReleaseCtx

typedef void(*	ReleaseProc) (ReleaseCtx)

Public Types inherited from GrIORef< GrGpuResource >
enum	LastRemovedRef

Public Member Functions
	~GrVkImage () override

VkImage	image () const

const skgpu::VulkanAlloc &	alloc () const

const GrVkImageInfo &	vkImageInfo () const

VkFormat	imageFormat () const

GrBackendFormat	backendFormat () const override

uint32_t	mipLevels () const

const skgpu::VulkanYcbcrConversionInfo &	ycbcrConversionInfo () const

VkImageUsageFlags	vkUsageFlags ()

bool	supportsInputAttachmentUsage () const

const GrVkImageView *	framebufferView () const

const GrVkImageView *	textureView () const

gr_rp< const GrVkDescriptorSet >	inputDescSetForBlending (GrVkGpu *gpu)

gr_rp< const GrVkDescriptorSet >	inputDescSetForMSAALoad (GrVkGpu *gpu)

const Resource *	resource () const

bool	isLinearTiled () const

bool	isBorrowed () const

sk_sp< skgpu::MutableTextureState >	getMutableState () const

VkImageLayout	currentLayout () const

void	setImageLayoutAndQueueIndex (const GrVkGpu *gpu, VkImageLayout newLayout, VkAccessFlags dstAccessMask, VkPipelineStageFlags dstStageMask, bool byRegion, uint32_t newQueueFamilyIndex)

void	setImageLayout (const GrVkGpu *gpu, VkImageLayout newLayout, VkAccessFlags dstAccessMask, VkPipelineStageFlags dstStageMask, bool byRegion)

uint32_t	currentQueueFamilyIndex () const

void	setQueueFamilyIndex (uint32_t queueFamilyIndex)

void	prepareForPresent (GrVkGpu *gpu)

void	prepareForExternal (GrVkGpu *gpu)

void	updateImageLayout (VkImageLayout newLayout)

void	setResourceRelease (sk_sp< RefCntedReleaseProc > releaseHelper)

Public Member Functions inherited from GrAttachment
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (UsageFlags)

	~GrAttachment () override

UsageFlags	supportedUsages () const

int	numSamples () const

skgpu::Mipmapped	mipmapped () const

bool	hasPerformedInitialClear () const

void	markHasPerformedInitialClear ()

Public Member Functions inherited from GrSurface
SkISize	dimensions () const

int	width () const

int	height () const

SkRect	getBoundsRect () const

virtual GrBackendFormat	backendFormat () const =0

void	setRelease (sk_sp< skgpu::RefCntedCallback > releaseHelper)

void	setRelease (ReleaseProc proc, ReleaseCtx ctx)

virtual GrTexture *	asTexture ()

virtual const GrTexture *	asTexture () const

virtual GrRenderTarget *	asRenderTarget ()

virtual const GrRenderTarget *	asRenderTarget () const

GrInternalSurfaceFlags	flags () const

bool	readOnly () const

bool	framebufferOnly () const

bool	isProtected () const

void	setFramebufferOnly ()

Public Member Functions inherited from GrGpuResource
bool	wasDestroyed () const

const GrDirectContext *	getContext () const

GrDirectContext *	getContext ()

size_t	gpuMemorySize () const

UniqueID	uniqueID () const

const skgpu::UniqueKey &	getUniqueKey () const

std::string	getLabel () const

void	setLabel (std::string_view label)

CacheAccess	cacheAccess ()

const CacheAccess	cacheAccess () const

ProxyAccess	proxyAccess ()

ResourcePriv	resourcePriv ()

const ResourcePriv	resourcePriv () const

virtual void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const

virtual const char *	getResourceType () const =0

Public Member Functions inherited from GrIORef< GrGpuResource >
bool	unique () const

void	ref () const

void	unref () const

void	refCommandBuffer () const

void	unrefCommandBuffer () const

Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default

	SkNoncopyable (SkNoncopyable &&)=default

SkNoncopyable &	operator= (SkNoncopyable &&)=default

Static Public Member Functions
static sk_sp< GrVkImage >	MakeStencil (GrVkGpu *gpu, SkISize dimensions, int sampleCnt, VkFormat format)

static sk_sp< GrVkImage >	MakeMSAA (GrVkGpu *gpu, SkISize dimensions, int numSamples, VkFormat format, GrProtected isProtected, GrMemoryless memoryless)

static sk_sp< GrVkImage >	MakeTexture (GrVkGpu *gpu, SkISize dimensions, VkFormat format, uint32_t mipLevels, GrRenderable renderable, int numSamples, skgpu::Budgeted budgeted, GrProtected isProtected)

static sk_sp< GrVkImage >	MakeWrapped (GrVkGpu *gpu, SkISize dimensions, const GrVkImageInfo &, sk_sp< skgpu::MutableTextureState >, UsageFlags attachmentUsages, GrWrapOwnership, GrWrapCacheable, std::string_view label, bool forSecondaryCB=false)

static bool	InitImageInfo (GrVkGpu gpu, const ImageDesc &imageDesc, GrVkImageInfo )

static void	DestroyImageInfo (const GrVkGpu gpu, GrVkImageInfo )

static VkPipelineStageFlags	LayoutToPipelineSrcStageFlags (const VkImageLayout layout)

static VkAccessFlags	LayoutToSrcAccessMask (const VkImageLayout layout)

Static Public Member Functions inherited from GrAttachment
static void	ComputeSharedAttachmentUniqueKey (const GrCaps &caps, const GrBackendFormat &format, SkISize dimensions, UsageFlags requiredUsage, int sampleCnt, skgpu::Mipmapped mipmapped, GrProtected isProtected, GrMemoryless memoryless, skgpu::UniqueKey *key)

static void	ComputeScratchKey (const GrCaps &caps, const GrBackendFormat &format, SkISize dimensions, UsageFlags requiredUsage, int sampleCnt, skgpu::Mipmapped mipmapped, GrProtected, GrMemoryless, skgpu::ScratchKey *key)

Static Public Member Functions inherited from GrSurface
static size_t	ComputeSize (const GrBackendFormat &, SkISize dimensions, int colorSamplesPerPixel, skgpu::Mipmapped, bool binSize=false)

Static Public Member Functions inherited from GrGpuResource
static uint32_t	CreateUniqueID ()

Friends
class	GrVkRenderTarget

Additional Inherited Members
Protected Member Functions inherited from GrAttachment
	GrAttachment (GrGpu *gpu, SkISize dimensions, UsageFlags supportedUsages, int sampleCnt, skgpu::Mipmapped mipmapped, GrProtected isProtected, std::string_view label, GrMemoryless memoryless=GrMemoryless::kNo)

Protected Member Functions inherited from GrSurface
void	setGLRTFBOIDIs0 ()

bool	glRTFBOIDis0 () const

void	setRequiresManualMSAAResolve ()

bool	requiresManualMSAAResolve () const

void	setReadOnly ()

void	setVkRTSupportsInputAttachment ()

	GrSurface (GrGpu *gpu, const SkISize &dimensions, skgpu::Protected isProtected, std::string_view label)

	~GrSurface () override

void	onRelease () override

void	onAbandon () override

Protected Member Functions inherited from GrGpuResource
void	registerWithCache (skgpu::Budgeted)

void	registerWithCacheWrapped (GrWrapCacheable)

	GrGpuResource (GrGpu *, std::string_view label)

virtual	~GrGpuResource ()

GrGpu *	getGpu () const

virtual void	onRelease ()

virtual void	onAbandon ()

virtual void	setMemoryBacking (SkTraceMemoryDump *, const SkString &) const

SkString	getResourceName () const

void	dumpMemoryStatisticsPriv (SkTraceMemoryDump traceMemoryDump, const SkString &resourceName, const char type, size_t size) const

Protected Member Functions inherited from GrIORef< GrGpuResource >
	GrIORef ()

bool	internalHasRef () const

bool	internalHasNoCommandBufferUsages () const

void	addInitialRef () const

Detailed Description

Definition at line 32 of file GrVkImage.h.

Member Typedef Documentation

◆ ReleaseCtx

typedef void* GrVkImage::ReleaseCtx

Definition at line 208 of file GrVkImage.h.

◆ ReleaseProc

typedef void(* GrVkImage::ReleaseProc) (ReleaseCtx)

Definition at line 209 of file GrVkImage.h.

Constructor & Destructor Documentation

◆ ~GrVkImage()

GrVkImage::~GrVkImage ( )

override

Definition at line 582 of file GrVkImage.cpp.

                      {
    // should have been released first
    SkASSERT(!fResource);
    SkASSERT(!fFramebufferView);
    SkASSERT(!fTextureView);
}

Member Function Documentation

◆ alloc()

const skgpu::VulkanAlloc & GrVkImage::alloc ( ) const

inline

Definition at line 76 of file GrVkImage.h.

                                          {
        // Should only be called when we have a real fResource object, i.e. never when being used as
        // a RT in an external secondary command buffer.
        SkASSERT(fResource);
        return fInfo.fAlloc;
    }

◆ backendFormat()

GrBackendFormat GrVkImage::backendFormat ( ) const

inlineoverridevirtual

Implements GrSurface.

Definition at line 84 of file GrVkImage.h.

                                                   {
        bool usesDRMModifier =
                this->vkImageInfo().fImageTiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
        if (fResource && this->ycbcrConversionInfo().isValid()) {
            SkASSERT(this->imageFormat() == this->ycbcrConversionInfo().fFormat);
            return GrBackendFormats::MakeVk(this->ycbcrConversionInfo(), usesDRMModifier);
        }
        SkASSERT(this->imageFormat() != VK_FORMAT_UNDEFINED);
        return GrBackendFormats::MakeVk(this->imageFormat(), usesDRMModifier);
    }

◆ currentLayout()

VkImageLayout GrVkImage::currentLayout ( ) const

inline

Definition at line 133 of file GrVkImage.h.

                                        {
        return skgpu::MutableTextureStates::GetVkImageLayout(fMutableState.get());
    }

◆ currentQueueFamilyIndex()

uint32_t GrVkImage::currentQueueFamilyIndex ( ) const

inline

Definition at line 153 of file GrVkImage.h.

                                             {
        return skgpu::MutableTextureStates::GetVkQueueFamilyIndex(fMutableState.get());
    }

◆ DestroyImageInfo()

void GrVkImage::DestroyImageInfo	(	const GrVkGpu *	gpu,
		GrVkImageInfo *	info
	)

static

Definition at line 577 of file GrVkImage.cpp.

                                                                        {
    VK_CALL(gpu, DestroyImage(gpu->device(), info->fImage, nullptr));
    skgpu::VulkanMemory::FreeImageMemory(gpu->memoryAllocator(), info->fAlloc);
}

◆ framebufferView()

const GrVkImageView * GrVkImage::framebufferView ( ) const

inline

Definition at line 106 of file GrVkImage.h.

106{ return fFramebufferView.get(); }

◆ getMutableState()

sk_sp< skgpu::MutableTextureState > GrVkImage::getMutableState ( ) const

inline

Definition at line 131 of file GrVkImage.h.

131{ return fMutableState; }

◆ image()

VkImage GrVkImage::image ( ) const

inline

Definition at line 70 of file GrVkImage.h.

                          {
        // Should only be called when we have a real fResource object, i.e. never when being used as
        // a RT in an external secondary command buffer.
        SkASSERT(fResource);
        return fInfo.fImage;
    }

◆ imageFormat()

VkFormat GrVkImage::imageFormat ( ) const

inline

Definition at line 83 of file GrVkImage.h.

83{ return fInfo.fFormat; }

GrVkImageInfo::fFormat

VkFormat fFormat

Definition: GrVkTypes.h:30

◆ InitImageInfo()

bool GrVkImage::InitImageInfo	(	GrVkGpu *	gpu,
		const ImageDesc &	imageDesc,
		GrVkImageInfo *	info
	)

static

Definition at line 471 of file GrVkImage.cpp.

                                                                                           {
    if (0 == imageDesc.fWidth || 0 == imageDesc.fHeight) {
        return false;
    }
    if ((imageDesc.fIsProtected == GrProtected::kYes) &&
        !gpu->vkCaps().supportsProtectedContent()) {
        return false;
    }
 
    bool isLinear = VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling;
    VkImageLayout initialLayout = isLinear ? VK_IMAGE_LAYOUT_PREINITIALIZED
                                           : VK_IMAGE_LAYOUT_UNDEFINED;
 
    // Create Image
    VkSampleCountFlagBits vkSamples;
    if (!skgpu::SampleCountToVkSampleCount(imageDesc.fSamples, &vkSamples)) {
        return false;
    }
 
    SkASSERT(VK_IMAGE_TILING_OPTIMAL == imageDesc.fImageTiling ||
             VK_SAMPLE_COUNT_1_BIT == vkSamples);
 
    VkImageCreateFlags createflags = 0;
    if (imageDesc.fIsProtected == GrProtected::kYes || gpu->protectedContext()) {
        createflags |= VK_IMAGE_CREATE_PROTECTED_BIT;
    }
    const VkImageCreateInfo imageCreateInfo = {
        VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,         // sType
        nullptr,                                     // pNext
        createflags,                                 // VkImageCreateFlags
        imageDesc.fImageType,                        // VkImageType
        imageDesc.fFormat,                           // VkFormat
        { imageDesc.fWidth, imageDesc.fHeight, 1 },  // VkExtent3D
        imageDesc.fLevels,                           // mipLevels
        1,                                           // arrayLayers
        vkSamples,                                   // samples
        imageDesc.fImageTiling,                      // VkImageTiling
        imageDesc.fUsageFlags,                       // VkImageUsageFlags
        VK_SHARING_MODE_EXCLUSIVE,                   // VkSharingMode
        0,                                           // queueFamilyCount
        nullptr,                                     // pQueueFamilyIndices
        initialLayout                                // initialLayout
    };
 
    VkImage image = VK_NULL_HANDLE;
    VkResult result;
    GR_VK_CALL_RESULT(gpu, result, CreateImage(gpu->device(), &imageCreateInfo, nullptr, &image));
    if (result != VK_SUCCESS) {
        return false;
    }
 
    skgpu::Protected isProtected = gpu->protectedContext() ? skgpu::Protected::kYes
                                                           : skgpu::Protected::kNo;
    bool forceDedicatedMemory = gpu->vkCaps().shouldAlwaysUseDedicatedImageMemory();
    bool useLazyAllocation =
            SkToBool(imageDesc.fUsageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT);
 
    auto checkResult = [gpu, isProtected, forceDedicatedMemory, useLazyAllocation](
                               VkResult result) {
        GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::AllocImageMemory"
                                 " (isProtected:%d, forceDedicatedMemory:%d, useLazyAllocation:%d)",
                                 (int)isProtected, (int)forceDedicatedMemory,
                                 (int)useLazyAllocation);
        return gpu->checkVkResult(result);
    };
    auto allocator = gpu->memoryAllocator();
    skgpu::VulkanAlloc alloc;
    if (!skgpu::VulkanMemory::AllocImageMemory(allocator,
                                               image,
                                               isProtected,
                                               forceDedicatedMemory,
                                               useLazyAllocation,
                                               checkResult,
                                               &alloc) ||
        (useLazyAllocation &&
         !SkToBool(alloc.fFlags & skgpu::VulkanAlloc::kLazilyAllocated_Flag))) {
        VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr));
        return false;
    }
 
    // Bind buffer
    GR_VK_CALL_RESULT(gpu, result, BindImageMemory(gpu->device(),
                                                   image,
                                                   alloc.fMemory,
                                                   alloc.fOffset));
    if (result) {
        skgpu::VulkanMemory::FreeImageMemory(allocator, alloc);
        VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr));
        return false;
    }
 
    info->fImage = image;
    info->fAlloc = alloc;
    info->fImageTiling = imageDesc.fImageTiling;
    info->fImageLayout = initialLayout;
    info->fFormat = imageDesc.fFormat;
    info->fImageUsageFlags = imageDesc.fUsageFlags;
    info->fSampleCount = imageDesc.fSamples;
    info->fLevelCount = imageDesc.fLevels;
    info->fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
    info->fProtected =
            (createflags & VK_IMAGE_CREATE_PROTECTED_BIT) ? GrProtected::kYes : GrProtected::kNo;
    info->fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
    return true;
}

◆ inputDescSetForBlending()

gr_rp< const GrVkDescriptorSet > GrVkImage::inputDescSetForBlending ( GrVkGpu * gpu )

Definition at line 670 of file GrVkImage.cpp.

                                                                              {
    if (!this->supportsInputAttachmentUsage()) {
        return nullptr;
    }
    if (fCachedBlendingInputDescSet) {
        return fCachedBlendingInputDescSet;
    }
 
    fCachedBlendingInputDescSet.reset(gpu->resourceProvider().getInputDescriptorSet());
    if (!fCachedBlendingInputDescSet) {
        return nullptr;
    }
 
    write_input_desc_set(gpu,
                         this->framebufferView()->imageView(),
                         VK_IMAGE_LAYOUT_GENERAL,
                         *fCachedBlendingInputDescSet->descriptorSet());
 
    return fCachedBlendingInputDescSet;
}

◆ inputDescSetForMSAALoad()

gr_rp< const GrVkDescriptorSet > GrVkImage::inputDescSetForMSAALoad ( GrVkGpu * gpu )

Definition at line 691 of file GrVkImage.cpp.

                                                                              {
    if (!this->supportsInputAttachmentUsage()) {
        return nullptr;
    }
    if (fCachedMSAALoadInputDescSet) {
        return fCachedMSAALoadInputDescSet;
    }
 
    fCachedMSAALoadInputDescSet.reset(gpu->resourceProvider().getInputDescriptorSet());
    if (!fCachedMSAALoadInputDescSet) {
        return nullptr;
    }
 
    write_input_desc_set(gpu,
                         this->framebufferView()->imageView(),
                         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                         *fCachedMSAALoadInputDescSet->descriptorSet());
 
    return fCachedMSAALoadInputDescSet;
}

◆ isBorrowed()

bool GrVkImage::isBorrowed ( ) const

inline

Definition at line 129 of file GrVkImage.h.

129{ return fIsBorrowed; }

◆ isLinearTiled()

bool GrVkImage::isLinearTiled ( ) const

inline

Definition at line 123 of file GrVkImage.h.

                               {
        // Should only be called when we have a real fResource object, i.e. never when being used as
        // a RT in an external secondary command buffer.
        SkASSERT(fResource);
        return SkToBool(VK_IMAGE_TILING_LINEAR == fInfo.fImageTiling);
    }

◆ LayoutToPipelineSrcStageFlags()

VkPipelineStageFlags GrVkImage::LayoutToPipelineSrcStageFlags ( const VkImageLayout layout )

static

Definition at line 312 of file GrVkImage.cpp.

                                                                                        {
    if (VK_IMAGE_LAYOUT_GENERAL == layout) {
        return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
    } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout ||
               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
        return VK_PIPELINE_STAGE_TRANSFER_BIT;
    } else if (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout) {
        return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    } else if (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL == layout ||
               VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == layout) {
        return VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
    } else if (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout) {
        return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    } else if (VK_IMAGE_LAYOUT_PREINITIALIZED == layout) {
        return VK_PIPELINE_STAGE_HOST_BIT;
    } else if (VK_IMAGE_LAYOUT_PRESENT_SRC_KHR == layout) {
        return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    }
 
    SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED == layout);
    return VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
}

◆ LayoutToSrcAccessMask()

VkAccessFlags GrVkImage::LayoutToSrcAccessMask ( const VkImageLayout layout )

static

Definition at line 335 of file GrVkImage.cpp.

                                                                         {
    // Currently we assume we will never being doing any explict shader writes (this doesn't include
    // color attachment or depth/stencil writes). So we will ignore the
    // VK_MEMORY_OUTPUT_SHADER_WRITE_BIT.
 
    // We can only directly access the host memory if we are in preinitialized or general layout,
    // and the image is linear.
    // TODO: Add check for linear here so we are not always adding host to general, and we should
    //       only be in preinitialized if we are linear
    VkAccessFlags flags = 0;
    if (VK_IMAGE_LAYOUT_GENERAL == layout) {
        flags = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
                VK_ACCESS_TRANSFER_WRITE_BIT |
                VK_ACCESS_HOST_WRITE_BIT;
    } else if (VK_IMAGE_LAYOUT_PREINITIALIZED == layout) {
        flags = VK_ACCESS_HOST_WRITE_BIT;
    } else if (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout) {
        flags = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    } else if (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL == layout) {
        flags = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    } else if (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
        flags = VK_ACCESS_TRANSFER_WRITE_BIT;
    } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout ||
               VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout ||
               VK_IMAGE_LAYOUT_PRESENT_SRC_KHR == layout) {
        // There are no writes that need to be made available
        flags = 0;
    }
    return flags;
}

◆ MakeMSAA()

sk_sp< GrVkImage > GrVkImage::MakeMSAA	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		int	numSamples,
		VkFormat	format,
		GrProtected	isProtected,
		GrMemoryless	memoryless
	)

static

Definition at line 39 of file GrVkImage.cpp.

                                                              {
    SkASSERT(numSamples > 1);
 
    VkImageUsageFlags vkUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
    if (memoryless == GrMemoryless::kYes) {
        vkUsageFlags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
    } else {
        vkUsageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    }
    return GrVkImage::Make(gpu,
                           dimensions,
                           UsageFlags::kColorAttachment,
                           numSamples,
                           format,
                           /*mipLevels=*/1,
                           vkUsageFlags,
                           isProtected,
                           memoryless,
                           skgpu::Budgeted::kYes);
}

◆ MakeStencil()

sk_sp< GrVkImage > GrVkImage::MakeStencil	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		int	sampleCnt,
		VkFormat	format
	)

static

Definition at line 21 of file GrVkImage.cpp.

                                                         {
    VkImageUsageFlags vkUsageFlags =
            VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    return GrVkImage::Make(gpu,
                           dimensions,
                           UsageFlags::kStencilAttachment,
                           sampleCnt,
                           format,
                           /*mipLevels=*/1,
                           vkUsageFlags,
                           GrProtected::kNo,
                           GrMemoryless::kNo,
                           skgpu::Budgeted::kYes);
}

◆ MakeTexture()

sk_sp< GrVkImage > GrVkImage::MakeTexture	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		VkFormat	format,
		uint32_t	mipLevels,
		GrRenderable	renderable,
		int	numSamples,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected
	)

static

Definition at line 65 of file GrVkImage.cpp.

                                                                 {
    UsageFlags usageFlags = UsageFlags::kTexture;
    VkImageUsageFlags vkUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
                                     VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    if (renderable == GrRenderable::kYes) {
        usageFlags |= UsageFlags::kColorAttachment;
        vkUsageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
        // We always make our render targets support being used as input attachments
        vkUsageFlags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
    }
 
    return GrVkImage::Make(gpu,
                           dimensions,
                           usageFlags,
                           numSamples,
                           format,
                           mipLevels,
                           vkUsageFlags,
                           isProtected,
                           GrMemoryless::kNo,
                           budgeted);
}

◆ MakeWrapped()

sk_sp< GrVkImage > GrVkImage::MakeWrapped	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		const GrVkImageInfo &	info,
		sk_sp< skgpu::MutableTextureState >	mutableState,
		UsageFlags	attachmentUsages,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable,
		std::string_view	label,
		bool	forSecondaryCB = `false`
	)

static

Definition at line 179 of file GrVkImage.cpp.

                                                             {
    sk_sp<const GrVkImageView> framebufferView;
    sk_sp<const GrVkImageView> textureView;
    if (!forSecondaryCB) {
        if (!make_views(gpu, info, attachmentUsages, &framebufferView, &textureView)) {
            return nullptr;
        }
    }
 
    GrBackendObjectOwnership backendOwnership = kBorrow_GrWrapOwnership == ownership
                                                        ? GrBackendObjectOwnership::kBorrowed
                                                        : GrBackendObjectOwnership::kOwned;
 
    return sk_sp<GrVkImage>(new GrVkImage(gpu,
                                          dimensions,
                                          attachmentUsages,
                                          info,
                                          std::move(mutableState),
                                          std::move(framebufferView),
                                          std::move(textureView),
                                          backendOwnership,
                                          cacheable,
                                          forSecondaryCB,
                                          label));
}

◆ mipLevels()

uint32_t GrVkImage::mipLevels ( ) const

inline

Definition at line 94 of file GrVkImage.h.

94{ return fInfo.fLevelCount; }

GrVkImageInfo::fLevelCount

uint32_t fLevelCount

Definition: GrVkTypes.h:33

◆ prepareForExternal()

void GrVkImage::prepareForExternal ( GrVkGpu * gpu )

Definition at line 601 of file GrVkImage.cpp.

                                               {
    this->setImageLayoutAndQueueIndex(gpu, this->currentLayout(), 0,
                                      VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, false,
                                     fInitialQueueFamily);
}

◆ prepareForPresent()

void GrVkImage::prepareForPresent ( GrVkGpu * gpu )

Definition at line 589 of file GrVkImage.cpp.

                                              {
    VkImageLayout layout = this->currentLayout();
    if (fInitialQueueFamily != VK_QUEUE_FAMILY_EXTERNAL &&
        fInitialQueueFamily != VK_QUEUE_FAMILY_FOREIGN_EXT) {
        if (gpu->vkCaps().supportsSwapchain()) {
            layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        }
    }
    this->setImageLayoutAndQueueIndex(gpu, layout, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, false,
                                      fInitialQueueFamily);
}

◆ resource()

const Resource * GrVkImage::resource ( ) const

inline

Definition at line 119 of file GrVkImage.h.

                                     {
        SkASSERT(fResource);
        return fResource;
    }

◆ setImageLayout()

void GrVkImage::setImageLayout	(	const GrVkGpu *	gpu,
		VkImageLayout	newLayout,
		VkAccessFlags	dstAccessMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion
	)

inline

Definition at line 144 of file GrVkImage.h.

                                       {
        this->setImageLayoutAndQueueIndex(gpu, newLayout, dstAccessMask, dstStageMask, byRegion,
                                          VK_QUEUE_FAMILY_IGNORED);
    }

◆ setImageLayoutAndQueueIndex()

void GrVkImage::setImageLayoutAndQueueIndex	(	const GrVkGpu *	gpu,
		VkImageLayout	newLayout,
		VkAccessFlags	dstAccessMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		uint32_t	newQueueFamilyIndex
	)

Definition at line 379 of file GrVkImage.cpp.

                                                                          {
// Enable the following block to test new devices to confirm their lazy images stay at 0 memory use.
#if 0
    if (fInfo.fAlloc.fFlags & skgpu::VulkanAlloc::kLazilyAllocated_Flag) {
        VkDeviceSize size;
        VK_CALL(gpu, GetDeviceMemoryCommitment(gpu->device(), fInfo.fAlloc.fMemory, &size));
 
        SkDebugf("Lazy Image. This: %p, image: %d, size: %d\n", this, fInfo.fImage, size);
    }
#endif
    SkASSERT(!gpu->isDeviceLost());
    SkASSERT(newLayout == this->currentLayout() ||
             (VK_IMAGE_LAYOUT_UNDEFINED != newLayout &&
              VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout));
    VkImageLayout currentLayout = this->currentLayout();
    uint32_t currentQueueIndex = this->currentQueueFamilyIndex();
 
#ifdef SK_DEBUG
    if (fInfo.fSharingMode == VK_SHARING_MODE_CONCURRENT) {
        if (newQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED) {
            SkASSERT(currentQueueIndex == VK_QUEUE_FAMILY_IGNORED ||
                     currentQueueIndex == VK_QUEUE_FAMILY_EXTERNAL ||
                     currentQueueIndex == VK_QUEUE_FAMILY_FOREIGN_EXT);
        } else {
            SkASSERT(newQueueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL ||
                     newQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT);
            SkASSERT(currentQueueIndex == VK_QUEUE_FAMILY_IGNORED);
        }
    } else {
        SkASSERT(fInfo.fSharingMode == VK_SHARING_MODE_EXCLUSIVE);
        if (newQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED ||
            currentQueueIndex == gpu->queueIndex()) {
            SkASSERT(currentQueueIndex == VK_QUEUE_FAMILY_IGNORED ||
                     currentQueueIndex == VK_QUEUE_FAMILY_EXTERNAL ||
                     currentQueueIndex == VK_QUEUE_FAMILY_FOREIGN_EXT ||
                     currentQueueIndex == gpu->queueIndex());
        } else if (newQueueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL ||
                   newQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT) {
            SkASSERT(currentQueueIndex == VK_QUEUE_FAMILY_IGNORED ||
                     currentQueueIndex == gpu->queueIndex());
        }
    }
#endif
 
    if (fInfo.fSharingMode == VK_SHARING_MODE_EXCLUSIVE) {
        if (newQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED) {
            newQueueFamilyIndex = gpu->queueIndex();
        }
        if (currentQueueIndex == VK_QUEUE_FAMILY_IGNORED) {
            currentQueueIndex = gpu->queueIndex();
        }
    }
 
    // If the old and new layout are the same and the layout is a read only layout, there is no need
    // to put in a barrier unless we also need to switch queues.
    if (newLayout == currentLayout && currentQueueIndex == newQueueFamilyIndex &&
        (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == currentLayout ||
         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == currentLayout ||
         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == currentLayout)) {
        return;
    }
 
    VkAccessFlags srcAccessMask = GrVkImage::LayoutToSrcAccessMask(currentLayout);
    VkPipelineStageFlags srcStageMask = GrVkImage::LayoutToPipelineSrcStageFlags(currentLayout);
 
    VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fInfo.fFormat);
 
    VkImageMemoryBarrier imageMemoryBarrier = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,          // sType
        nullptr,                                         // pNext
        srcAccessMask,                                   // srcAccessMask
        dstAccessMask,                                   // dstAccessMask
        currentLayout,                                   // oldLayout
        newLayout,                                       // newLayout
        currentQueueIndex,                               // srcQueueFamilyIndex
        newQueueFamilyIndex,                             // dstQueueFamilyIndex
        fInfo.fImage,                                    // image
        { aspectFlags, 0, fInfo.fLevelCount, 0, 1 }      // subresourceRange
    };
    SkASSERT(srcAccessMask == imageMemoryBarrier.srcAccessMask);
    gpu->addImageMemoryBarrier(this->resource(), srcStageMask, dstStageMask, byRegion,
                               &imageMemoryBarrier);
 
    this->updateImageLayout(newLayout);
    this->setQueueFamilyIndex(newQueueFamilyIndex);
}

◆ setQueueFamilyIndex()

void GrVkImage::setQueueFamilyIndex ( uint32_t queueFamilyIndex )

inline

Definition at line 157 of file GrVkImage.h.

                                                        {
        skgpu::MutableTextureStates::SetVkQueueFamilyIndex(fMutableState.get(), queueFamilyIndex);
    }

◆ setResourceRelease()

void GrVkImage::setResourceRelease ( sk_sp< RefCntedReleaseProc > releaseHelper )

Definition at line 628 of file GrVkImage.cpp.

                                                                           {
    SkASSERT(fResource);
    // Forward the release proc on to GrVkImage::Resource
    fResource->setRelease(std::move(releaseHelper));
}

◆ supportsInputAttachmentUsage()

bool GrVkImage::supportsInputAttachmentUsage ( ) const

inline

Definition at line 102 of file GrVkImage.h.

                                              {
        return fInfo.fImageUsageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
    }

◆ textureView()

const GrVkImageView * GrVkImage::textureView ( ) const

inline

Definition at line 107 of file GrVkImage.h.

107{ return fTextureView.get(); }

◆ updateImageLayout()

void GrVkImage::updateImageLayout ( VkImageLayout newLayout )

inline

Definition at line 171 of file GrVkImage.h.

                                                    {
        // Should only be called when we have a real fResource object, i.e. never when being used as
        // a RT in an external secondary command buffer.
        SkASSERT(fResource);
        skgpu::MutableTextureStates::SetVkImageLayout(fMutableState.get(), newLayout);
    }

◆ vkImageInfo()

const GrVkImageInfo & GrVkImage::vkImageInfo ( ) const

inline

Definition at line 82 of file GrVkImage.h.

82{ return fInfo; }

◆ vkUsageFlags()

VkImageUsageFlags GrVkImage::vkUsageFlags ( )

inline

Definition at line 101 of file GrVkImage.h.

101{ return fInfo.fImageUsageFlags; }

◆ ycbcrConversionInfo()

const skgpu::VulkanYcbcrConversionInfo & GrVkImage::ycbcrConversionInfo ( ) const

inline

Definition at line 95 of file GrVkImage.h.

                                                                      {
        // Should only be called when we have a real fResource object, i.e. never when being used as
        // a RT in an external secondary command buffer.
        SkASSERT(fResource);
        return fInfo.fYcbcrConversionInfo;
    }

Friends And Related Function Documentation

◆ GrVkRenderTarget

friend class GrVkRenderTarget

friend

Definition at line 331 of file GrVkImage.h.

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

third_party/skia/src/gpu/ganesh/vk/GrVkImage.h
third_party/skia/src/gpu/ganesh/vk/GrVkImage.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ReleaseCtx

◆ ReleaseProc

Constructor & Destructor Documentation

◆ ~GrVkImage()

Member Function Documentation

◆ alloc()

◆ backendFormat()

◆ currentLayout()

◆ currentQueueFamilyIndex()

◆ DestroyImageInfo()

◆ framebufferView()

◆ getMutableState()

◆ image()

◆ imageFormat()

◆ InitImageInfo()

◆ inputDescSetForBlending()

◆ inputDescSetForMSAALoad()

◆ isBorrowed()

◆ isLinearTiled()

◆ LayoutToPipelineSrcStageFlags()

◆ LayoutToSrcAccessMask()

◆ MakeMSAA()

◆ MakeStencil()

◆ MakeTexture()

◆ MakeWrapped()

◆ mipLevels()

◆ prepareForExternal()

◆ prepareForPresent()

◆ resource()

◆ setImageLayout()

◆ setImageLayoutAndQueueIndex()

◆ setQueueFamilyIndex()

◆ setResourceRelease()

◆ supportsInputAttachmentUsage()

◆ textureView()

◆ updateImageLayout()

◆ vkImageInfo()

◆ vkUsageFlags()

◆ ycbcrConversionInfo()

Friends And Related Function Documentation

◆ GrVkRenderTarget