#include <GrVkCaps.h>

Inheritance diagram for GrVkCaps:

Public Member Functions
	GrVkCaps (const GrContextOptions &, const skgpu::VulkanInterface *, VkPhysicalDevice, const VkPhysicalDeviceFeatures2 &, uint32_t instanceVersion, uint32_t physicalDeviceVersion, const skgpu::VulkanExtensions &, skgpu::Protected)

bool	isFormatSRGB (const GrBackendFormat &) const override

bool	isFormatTexturable (const GrBackendFormat &, GrTextureType) const override

bool	isVkFormatTexturable (VkFormat) const

bool	isFormatCopyable (const GrBackendFormat &) const override

bool	isFormatAsColorTypeRenderable (GrColorType ct, const GrBackendFormat &format, int sampleCount=1) const override

bool	isFormatRenderable (const GrBackendFormat &format, int sampleCount) const override

bool	isFormatRenderable (VkFormat, int sampleCount) const

int	getRenderTargetSampleCount (int requestedCount, const GrBackendFormat &) const override

int	getRenderTargetSampleCount (int requestedCount, VkFormat) const

int	maxRenderTargetSampleCount (const GrBackendFormat &) const override

int	maxRenderTargetSampleCount (VkFormat format) const

SupportedWrite	supportedWritePixelsColorType (GrColorType surfaceColorType, const GrBackendFormat &surfaceFormat, GrColorType srcColorType) const override

SurfaceReadPixelsSupport	surfaceSupportsReadPixels (const GrSurface *) const override

bool	isVkFormatTexturableLinearly (VkFormat format) const

bool	formatCanBeDstofBlit (VkFormat format, bool linearTiled) const

bool	formatCanBeSrcofBlit (VkFormat format, bool linearTiled) const

GrColorType	transferColorType (VkFormat, GrColorType surfaceColorType) const

bool	mustSyncCommandBuffersWithQueue () const

bool	shouldAlwaysUseDedicatedImageMemory () const

bool	avoidUpdateBuffers () const

VkFormat	preferredStencilFormat () const

bool	supportsSwapchain () const

bool	supportsPhysicalDeviceProperties2 () const

bool	supportsMemoryRequirements2 () const

bool	supportsBindMemory2 () const

bool	supportsMaintenance1 () const

bool	supportsMaintenance2 () const

bool	supportsMaintenance3 () const

bool	supportsDedicatedAllocation () const

bool	supportsExternalMemory () const

bool	supportsAndroidHWBExternalMemory () const

bool	supportsYcbcrConversion () const

uint32_t	ycbcrCombinedImageSamplerDescriptorCount () const

bool	supportsDRMFormatModifiers () const

bool	supportsDeviceFaultInfo () const

bool	preferPrimaryOverSecondaryCommandBuffers () const

int	maxPerPoolCachedSecondaryCommandBuffers () const

uint32_t	maxInputAttachmentDescriptors () const

float	maxSamplerAnisotropy () const

bool	mustInvalidatePrimaryCmdBufferStateAfterClearAttachments () const

bool	gpuOnlyBuffersMorePerformant () const

bool	shouldPersistentlyMapCpuToGpuBuffers () const

uint32_t	maxDrawIndirectDrawCount () const

bool	canCopyImage (VkFormat dstFormat, int dstSampleCnt, bool dstHasYcbcr, VkFormat srcFormat, int srcSamplecnt, bool srcHasYcbcr) const

bool	canCopyAsBlit (VkFormat dstConfig, int dstSampleCnt, bool dstIsLinear, bool dstHasYcbcr, VkFormat srcConfig, int srcSampleCnt, bool srcIsLinear, bool srcHasYcbcr) const

bool	canCopyAsResolve (VkFormat dstConfig, int dstSampleCnt, bool dstHasYcbcr, VkFormat srcConfig, int srcSamplecnt, bool srcHasYcbcr) const

GrBackendFormat	getBackendFormatFromCompressionType (SkTextureCompressionType) const override

VkFormat	getFormatFromColorType (GrColorType colorType) const

skgpu::Swizzle	getWriteSwizzle (const GrBackendFormat &, GrColorType) const override

uint64_t	computeFormatKey (const GrBackendFormat &) const override

int	getFragmentUniformBinding () const

int	getFragmentUniformSet () const

void	addExtraSamplerKey (skgpu::KeyBuilder *, GrSamplerState, const GrBackendFormat &) const override

GrProgramDesc	makeDesc (GrRenderTarget *, const GrProgramInfo &, ProgramDescOverrideFlags) const override

GrInternalSurfaceFlags	getExtraSurfaceFlagsForDeferredRT () const override

VkShaderStageFlags	getPushConstantStageFlags () const

bool	mustLoadFullImageWithDiscardableMSAA () const

bool	supportsDiscardableMSAAForDMSAA () const

bool	renderTargetSupportsDiscardableMSAA (const GrVkRenderTarget *) const

bool	programInfoWillUseDiscardableMSAA (const GrProgramInfo &) const

bool	dmsaaResolveCanBeUsedAsTextureInSameRenderPass () const override

bool	supportsMemorylessAttachments () const

Public Member Functions inherited from GrCaps
	GrCaps (const GrContextOptions &)

void	dumpJSON (SkJSONWriter *) const

const GrShaderCaps *	shaderCaps () const

bool	npotTextureTileSupport () const

bool	mipmapSupport () const

bool	anisoSupport () const

bool	gpuTracingSupport () const

bool	oversizedStencilSupport () const

bool	textureBarrierSupport () const

bool	sampleLocationsSupport () const

bool	drawInstancedSupport () const

bool	nativeDrawIndirectSupport () const

bool	useClientSideIndirectBuffers () const

bool	conservativeRasterSupport () const

bool	wireframeSupport () const

bool	msaaResolvesAutomatically () const

bool	preferDiscardableMSAAAttachment () const

bool	halfFloatVertexAttributeSupport () const

bool	usePrimitiveRestart () const

bool	preferClientSideDynamicBuffers () const

bool	preferFullscreenClears () const

bool	discardStencilValuesAfterRenderPass () const

bool	twoSidedStencilRefsAndMasksMustMatch () const

bool	preferVRAMUseOverFlushes () const

bool	avoidStencilBuffers () const

bool	avoidWritePixelsFastPath () const

bool	nativeDrawIndexedIndirectIsBroken () const

BlendEquationSupport	blendEquationSupport () const

bool	advancedBlendEquationSupport () const

bool	advancedCoherentBlendEquationSupport () const

bool	isAdvancedBlendEquationDisabled (skgpu::BlendEquation equation) const

bool	shouldCollapseSrcOverToSrcWhenAble () const

bool	mustSyncGpuDuringAbandon () const

bool	reducedShaderMode () const

uint32_t	mapBufferFlags () const

bool	reuseScratchTextures () const

bool	reuseScratchBuffers () const

int	maxVertexAttributes () const
	maximum number of attribute values per vertex

int	maxRenderTargetSize () const

int	maxPreferredRenderTargetSize () const

int	maxTextureSize () const

int	maxWindowRectangles () const

bool	isWindowRectanglesSupportedForRT (const GrBackendRenderTarget &rt) const

uint32_t	maxPushConstantsSize () const

size_t	transferBufferRowBytesAlignment () const

size_t	transferFromBufferToBufferAlignment () const

size_t	bufferUpdateDataPreserveAlignment () const

bool	isFormatCompressed (const GrBackendFormat &format) const

int	internalMultisampleCount (const GrBackendFormat &format) const

bool	surfaceSupportsWritePixels (const GrSurface *) const

SupportedRead	supportedReadPixelsColorType (GrColorType srcColorType, const GrBackendFormat &srcFormat, GrColorType dstColorType) const

bool	writePixelsRowBytesSupport () const

bool	transferPixelsToRowBytesSupport () const

bool	readPixelsRowBytesSupport () const

bool	transferFromSurfaceToBufferSupport () const

bool	transferFromBufferToTextureSupport () const

bool	transferFromBufferToBufferSupport () const

bool	suppressPrints () const

size_t	bufferMapThreshold () const

bool	mustClearUploadedBufferData () const

bool	shouldInitializeTextures () const

bool	buffersAreInitiallyZero () const

bool	supportsAHardwareBufferImages () const

bool	wireframeMode () const

bool	semaphoreSupport () const

bool	backendSemaphoreSupport () const

bool	finishedProcAsyncCallbackSupport () const

bool	crossContextTextureSupport () const

bool	canCopySurface (const GrSurfaceProxy dst, const SkIRect &dstRect, const GrSurfaceProxy src, const SkIRect &srcRect) const

bool	dynamicStateArrayGeometryProcessorTextureSupport () const

bool	supportsProtectedContent () const

bool	performPartialClearsAsDraws () const

bool	performColorClearsAsDraws () const

bool	avoidLargeIndexBufferDraws () const

bool	performStencilClearsAsDraws () const

bool	disableTessellationPathRenderer () const

GrDstSampleFlags	getDstSampleFlagsForProxy (const GrRenderTargetProxy *, bool drawUsesMSAA) const

virtual DstCopyRestrictions	getDstCopyRestrictions (const GrRenderTargetProxy *src, GrColorType ct) const

bool	validateSurfaceParams (const SkISize &, const GrBackendFormat &, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Mipmapped, GrTextureType) const

bool	areColorTypeAndFormatCompatible (GrColorType grCT, const GrBackendFormat &format) const

GrBackendFormat	getDefaultBackendFormat (GrColorType, GrRenderable) const

bool	clampToBorderSupport () const

skgpu::Swizzle	getReadSwizzle (const GrBackendFormat &format, GrColorType colorType) const

const GrDriverBugWorkarounds &	workarounds () const

	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (ProgramDescOverrideFlags)

bool	supportsDynamicMSAA (const GrRenderTargetProxy *) const

bool	avoidReorderingRenderTasks () const

bool	avoidDithering () const

bool	disablePerspectiveSDFText () const

bool	avoidLineDraws () const

std::tuple< GrColorType, GrBackendFormat >	getFallbackColorTypeAndFormat (GrColorType, int sampleCount) const

Public Member Functions inherited from SkCapabilities
SkSL::Version	skslVersion () const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static int	GetStencilFormatTotalBitCount (VkFormat format)

Static Public Member Functions inherited from SkCapabilities
static sk_sp< const SkCapabilities >	RasterBackend ()

Private Member Functions
bool	onSurfaceSupportsWritePixels (const GrSurface *) const override

bool	onCanCopySurface (const GrSurfaceProxy dst, const SkIRect &dstRect, const GrSurfaceProxy src, const SkIRect &srcRect) const override

GrBackendFormat	onGetDefaultBackendFormat (GrColorType) const override

bool	onAreColorTypeAndFormatCompatible (GrColorType, const GrBackendFormat &) const override

SupportedRead	onSupportedReadPixelsColorType (GrColorType, const GrBackendFormat &, GrColorType) const override

skgpu::Swizzle	onGetReadSwizzle (const GrBackendFormat &, GrColorType) const override

GrDstSampleFlags	onGetDstSampleFlagsForProxy (const GrRenderTargetProxy *) const override

bool	onSupportsDynamicMSAA (const GrRenderTargetProxy *) const override

Additional Inherited Members
Public Types inherited from GrCaps
enum	BlendEquationSupport { kBasic_BlendEquationSupport , kAdvanced_BlendEquationSupport , kAdvancedCoherent_BlendEquationSupport , kLast_BlendEquationSupport = kAdvancedCoherent_BlendEquationSupport }

enum	MapFlags { kNone_MapFlags = 0x0 , kCanMap_MapFlag = 0x1 , kSubset_MapFlag = 0x2 , kAsyncRead_MapFlag = 0x4 }

enum class	SurfaceReadPixelsSupport { kSupported , kCopyToTexture2D , kUnsupported }

enum class	ProgramDescOverrideFlags { kNone = 0 , kVulkanHasResolveLoadSubpass = 0x1 }

Protected Member Functions inherited from GrCaps
void	finishInitialization (const GrContextOptions &options)

Protected Member Functions inherited from SkCapabilities
	SkCapabilities ()=default

void	initSkCaps (const SkSL::ShaderCaps *)

Protected Attributes inherited from GrCaps
std::unique_ptr< GrShaderCaps >	fShaderCaps

bool	fNPOTTextureTileSupport: 1

bool	fMipmapSupport: 1

bool	fAnisoSupport: 1

bool	fReuseScratchTextures: 1

bool	fReuseScratchBuffers: 1

bool	fGpuTracingSupport: 1

bool	fOversizedStencilSupport: 1

bool	fTextureBarrierSupport: 1

bool	fSampleLocationsSupport: 1

bool	fDrawInstancedSupport: 1

bool	fNativeDrawIndirectSupport: 1

bool	fUseClientSideIndirectBuffers: 1

bool	fConservativeRasterSupport: 1

bool	fWireframeSupport: 1

bool	fMSAAResolvesAutomatically: 1

bool	fPreferDiscardableMSAAAttachment: 1

bool	fUsePrimitiveRestart: 1

bool	fPreferClientSideDynamicBuffers: 1

bool	fPreferFullscreenClears: 1

bool	fTwoSidedStencilRefsAndMasksMustMatch: 1

bool	fMustClearUploadedBufferData: 1

bool	fBuffersAreInitiallyZero: 1

bool	fShouldInitializeTextures: 1

bool	fSupportsAHardwareBufferImages: 1

bool	fHalfFloatVertexAttributeSupport: 1

bool	fClampToBorderSupport: 1

bool	fPerformPartialClearsAsDraws: 1

bool	fPerformColorClearsAsDraws: 1

bool	fAvoidLargeIndexBufferDraws: 1

bool	fPerformStencilClearsAsDraws: 1

bool	fTransferFromBufferToTextureSupport: 1

bool	fTransferFromSurfaceToBufferSupport: 1

bool	fTransferFromBufferToBufferSupport: 1

bool	fWritePixelsRowBytesSupport: 1

bool	fTransferPixelsToRowBytesSupport: 1

bool	fReadPixelsRowBytesSupport: 1

bool	fShouldCollapseSrcOverToSrcWhenAble: 1

bool	fMustSyncGpuDuringAbandon: 1

bool	fDisableTessellationPathRenderer: 1

bool	fAvoidStencilBuffers: 1

bool	fAvoidWritePixelsFastPath: 1

bool	fNativeDrawIndexedIndirectIsBroken: 1

bool	fAvoidReorderingRenderTasks: 1

bool	fAvoidDithering: 1

bool	fDisablePerspectiveSDFText: 1

bool	fAvoidLineDraws: 1

bool	fPreferVRAMUseOverFlushes: 1

bool	fSemaphoreSupport: 1

bool	fBackendSemaphoreSupport: 1

bool	fFinishedProcAsyncCallbackSupport: 1

bool	fCrossContextTextureSupport: 1

bool	fDynamicStateArrayGeometryProcessorTextureSupport: 1

bool	fSupportsProtectedContent: 1

BlendEquationSupport	fBlendEquationSupport

uint32_t	fAdvBlendEqDisableFlags

uint32_t	fMapBufferFlags

int	fBufferMapThreshold

int	fMaxRenderTargetSize

int	fMaxPreferredRenderTargetSize

int	fMaxVertexAttributes

int	fMaxTextureSize

int	fMaxWindowRectangles

int	fInternalMultisampleCount

uint32_t	fMaxPushConstantsSize = 0

size_t	fTransferBufferRowBytesAlignment = 1

size_t	fTransferFromBufferToBufferAlignment = 1

size_t	fBufferUpdateDataPreserveAlignment = 1

GrDriverBugWorkarounds	fDriverBugWorkarounds

Protected Attributes inherited from SkCapabilities
SkSL::Version	fSkSLVersion = SkSL::Version::k100

Detailed Description

Stores some capabilities of a Vk backend.

Definition at line 27 of file GrVkCaps.h.

Constructor & Destructor Documentation

◆ GrVkCaps()

GrVkCaps::GrVkCaps	(	const GrContextOptions &	contextOptions,
		const skgpu::VulkanInterface *	vkInterface,
		VkPhysicalDevice	physDev,
		const VkPhysicalDeviceFeatures2 &	features,
		uint32_t	instanceVersion,
		uint32_t	physicalDeviceVersion,
		const skgpu::VulkanExtensions &	extensions,
		skgpu::Protected	isProtected
	)

Creates a GrVkCaps that is set such that nothing is supported. The init function should be called to fill out the caps.

Definition at line 42 of file GrVkCaps.cpp.

        : INHERITED(contextOptions) {
    /**************************************************************************
     * GrCaps fields
     **************************************************************************/
    fMipmapSupport = true;   // always available in Vulkan
    fAnisoSupport = true;   // always available in Vulkan
    fNPOTTextureTileSupport = true;  // always available in Vulkan
    fReuseScratchTextures = true; //TODO: figure this out
    fGpuTracingSupport = false; //TODO: figure this out
    fOversizedStencilSupport = false; //TODO: figure this out
    fDrawInstancedSupport = true;
 
    fSemaphoreSupport = true;   // always available in Vulkan
    fBackendSemaphoreSupport = true;
    fFinishedProcAsyncCallbackSupport = true;
    fCrossContextTextureSupport = true;
    fHalfFloatVertexAttributeSupport = true;
 
    // We always copy in/out of a transfer buffer so it's trivial to support row bytes.
    fReadPixelsRowBytesSupport = true;
    fWritePixelsRowBytesSupport = true;
 
    fTransferFromBufferToTextureSupport = true;
    fTransferFromSurfaceToBufferSupport = true;
    fTransferFromBufferToBufferSupport  = true;
 
    fMaxRenderTargetSize = 4096; // minimum required by spec
    fMaxTextureSize = 4096; // minimum required by spec
 
    fDynamicStateArrayGeometryProcessorTextureSupport = true;
 
    fTextureBarrierSupport = true;
 
    fShaderCaps = std::make_unique<GrShaderCaps>();
 
    this->init(contextOptions, vkInterface, physDev, features, physicalDeviceVersion, extensions,
               isProtected);
}

Member Function Documentation

◆ addExtraSamplerKey()

void GrVkCaps::addExtraSamplerKey	(	skgpu::KeyBuilder *	,
		GrSamplerState	,
		const GrBackendFormat &
	)		const

overridevirtual

Adds fields to the key to represent the sampler that will be created for the passed in parameters. Currently this extra keying is only needed when building a vulkan pipeline with immutable samplers.

Reimplemented from GrCaps.

Definition at line 1930 of file GrVkCaps.cpp.

                                                                       {
    const GrVkYcbcrConversionInfo* ycbcrInfo = GrBackendFormats::GetVkYcbcrConversionInfo(format);
    if (!ycbcrInfo) {
        return;
    }
 
    GrVkSampler::Key key = GrVkSampler::GenerateKey(samplerState, *ycbcrInfo);
 
    constexpr size_t numInts = (sizeof(key) + 3) / 4;
    uint32_t tmp[numInts];
    memcpy(tmp, &key, sizeof(key));
 
    for (size_t i = 0; i < numInts; ++i) {
        b->add32(tmp[i]);
    }
}

◆ avoidUpdateBuffers()

bool GrVkCaps::avoidUpdateBuffers ( ) const

inline

Definition at line 99 of file GrVkCaps.h.

99{ return fAvoidUpdateBuffers; }

◆ canCopyAsBlit()

bool GrVkCaps::canCopyAsBlit	(	VkFormat	dstConfig,
		int	dstSampleCnt,
		bool	dstIsLinear,
		bool	dstHasYcbcr,
		VkFormat	srcConfig,
		int	srcSampleCnt,
		bool	srcIsLinear,
		bool	srcHasYcbcr
	)		const

Definition at line 169 of file GrVkCaps.cpp.

                                                                       {
    // We require that all vulkan GrSurfaces have been created with transfer_dst and transfer_src
    // as image usage flags.
    if (!this->formatCanBeDstofBlit(dstFormat, dstIsLinear) ||
        !this->formatCanBeSrcofBlit(srcFormat, srcIsLinear)) {
        return false;
    }
 
    // We cannot blit images that are multisampled. Will need to figure out if we can blit the
    // resolved msaa though.
    if (dstSampleCnt > 1 || srcSampleCnt > 1) {
        return false;
    }
 
    if (dstHasYcbcr || srcHasYcbcr) {
        return false;
    }
 
    return true;
}

◆ canCopyAsResolve()

bool GrVkCaps::canCopyAsResolve	(	VkFormat	dstConfig,
		int	dstSampleCnt,
		bool	dstHasYcbcr,
		VkFormat	srcConfig,
		int	srcSamplecnt,
		bool	srcHasYcbcr
	)		const

Definition at line 192 of file GrVkCaps.cpp.

                                                                                              {
    // The src surface must be multisampled.
    if (srcSampleCnt <= 1) {
        return false;
    }
 
    // The dst must not be multisampled.
    if (dstSampleCnt > 1) {
        return false;
    }
 
    // Surfaces must have the same format.
    if (srcFormat != dstFormat) {
        return false;
    }
 
    if (dstHasYcbcr || srcHasYcbcr) {
        return false;
    }
 
    return true;
}

◆ canCopyImage()

bool GrVkCaps::canCopyImage	(	VkFormat	dstFormat,
		int	dstSampleCnt,
		bool	dstHasYcbcr,
		VkFormat	srcFormat,
		int	srcSamplecnt,
		bool	srcHasYcbcr
	)		const

Helpers used by canCopySurface. In all cases if the SampleCnt parameter is zero that means the surface is not a render target, otherwise it is the number of samples in the render target.

Definition at line 154 of file GrVkCaps.cpp.

                                                                                          {
    if ((dstSampleCnt > 1 || srcSampleCnt > 1) && dstSampleCnt != srcSampleCnt) {
        return false;
    }
 
    if (dstHasYcbcr || srcHasYcbcr) {
        return false;
    }
 
    // We require that all Vulkan GrSurfaces have been created with transfer_dst and transfer_src
    // as image usage flags.
    return format_compatibility_class(srcFormat) == format_compatibility_class(dstFormat);
}

◆ computeFormatKey()

uint64_t GrVkCaps::computeFormatKey ( const GrBackendFormat & format ) const

overridevirtual

Implements GrCaps.

Definition at line 1876 of file GrVkCaps.cpp.

                                                                       {
    VkFormat vkFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(format, &vkFormat));
 
#ifdef SK_DEBUG
    // We should never be trying to compute a key for an external format
    const GrVkYcbcrConversionInfo* ycbcrInfo = GrBackendFormats::GetVkYcbcrConversionInfo(format);
    SkASSERT(ycbcrInfo);
    SkASSERT(!ycbcrInfo->isValid() || ycbcrInfo->fExternalFormat == 0);
#endif
 
    // A VkFormat has a size of 64 bits.
    return (uint64_t)vkFormat;
}

◆ dmsaaResolveCanBeUsedAsTextureInSameRenderPass()

bool GrVkCaps::dmsaaResolveCanBeUsedAsTextureInSameRenderPass ( ) const

inlineoverridevirtual

Reimplemented from GrCaps.

Definition at line 266 of file GrVkCaps.h.

266{ return false; }

◆ formatCanBeDstofBlit()

bool GrVkCaps::formatCanBeDstofBlit	(	VkFormat	format,
		bool	linearTiled
	)		const

inline

Definition at line 71 of file GrVkCaps.h.

                                                                       {
        const FormatInfo& info = this->getFormatInfo(format);
        const uint16_t& flags = linearTiled ? info.fLinearFlags : info.fOptimalFlags;
        return SkToBool(FormatInfo::kBlitDst_Flag & flags);
    }

◆ formatCanBeSrcofBlit()

bool GrVkCaps::formatCanBeSrcofBlit	(	VkFormat	format,
		bool	linearTiled
	)		const

inline

Definition at line 77 of file GrVkCaps.h.

                                                                       {
        const FormatInfo& info = this->getFormatInfo(format);
        const uint16_t& flags = linearTiled ? info.fLinearFlags : info.fOptimalFlags;
        return SkToBool(FormatInfo::kBlitSrc_Flag & flags);
    }

◆ getBackendFormatFromCompressionType()

GrBackendFormat GrVkCaps::getBackendFormatFromCompressionType ( SkTextureCompressionType compressionType ) const

overridevirtual

Implements GrCaps.

Definition at line 1800 of file GrVkCaps.cpp.

                                                        {
    switch (compressionType) {
        case SkTextureCompressionType::kNone:
            return {};
        case SkTextureCompressionType::kETC2_RGB8_UNORM:
            if (this->isVkFormatTexturable(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK)) {
                return GrBackendFormats::MakeVk(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK);
            }
            return {};
        case SkTextureCompressionType::kBC1_RGB8_UNORM:
            if (this->isVkFormatTexturable(VK_FORMAT_BC1_RGB_UNORM_BLOCK)) {
                return GrBackendFormats::MakeVk(VK_FORMAT_BC1_RGB_UNORM_BLOCK);
            }
            return {};
        case SkTextureCompressionType::kBC1_RGBA8_UNORM:
            if (this->isVkFormatTexturable(VK_FORMAT_BC1_RGBA_UNORM_BLOCK)) {
                return GrBackendFormats::MakeVk(VK_FORMAT_BC1_RGBA_UNORM_BLOCK);
            }
            return {};
    }
 
    SkUNREACHABLE;
}

◆ getExtraSurfaceFlagsForDeferredRT()

GrInternalSurfaceFlags GrVkCaps::getExtraSurfaceFlagsForDeferredRT ( ) const

overridevirtual

Reimplemented from GrCaps.

Definition at line 2049 of file GrVkCaps.cpp.

                                                                         {
    // We always create vulkan RT with the input attachment flag;
    return GrInternalSurfaceFlags::kVkRTSupportsInputAttachment;
}

◆ getFormatFromColorType()

VkFormat GrVkCaps::getFormatFromColorType ( GrColorType colorType ) const

inline

Definition at line 235 of file GrVkCaps.h.

                                                                 {
        int idx = static_cast<int>(colorType);
        return fColorTypeToFormatTable[idx];
    }

◆ getFragmentUniformBinding()

int GrVkCaps::getFragmentUniformBinding ( ) const

Definition at line 1922 of file GrVkCaps.cpp.

                                              {
    return GrVkUniformHandler::kUniformBinding;
}

◆ getFragmentUniformSet()

int GrVkCaps::getFragmentUniformSet ( ) const

Definition at line 1926 of file GrVkCaps.cpp.

                                          {
    return GrVkUniformHandler::kUniformBufferDescSet;
}

◆ getPushConstantStageFlags()

VkShaderStageFlags GrVkCaps::getPushConstantStageFlags ( ) const

Definition at line 2054 of file GrVkCaps.cpp.

                                                             {
    VkShaderStageFlags stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
    return stageFlags;
}

◆ getRenderTargetSampleCount() [1/2]

int GrVkCaps::getRenderTargetSampleCount	(	int	requestedCount,
		const GrBackendFormat &	format
	)		const

overridevirtual

Implements GrCaps.

Definition at line 1597 of file GrVkCaps.cpp.

                                                                              {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return 0;
    }
 
    return this->getRenderTargetSampleCount(requestedCount, vkFormat);
}

◆ getRenderTargetSampleCount() [2/2]

int GrVkCaps::getRenderTargetSampleCount	(	int	requestedCount,
		VkFormat	format
	)		const

Definition at line 1607 of file GrVkCaps.cpp.

                                                                                  {
    requestedCount = std::max(1, requestedCount);
 
    const FormatInfo& info = this->getFormatInfo(format);
 
    int count = info.fColorSampleCounts.size();
 
    if (!count) {
        return 0;
    }
 
    if (1 == requestedCount) {
        SkASSERT(!info.fColorSampleCounts.empty() && info.fColorSampleCounts[0] == 1);
        return 1;
    }
 
    for (int i = 0; i < count; ++i) {
        if (info.fColorSampleCounts[i] >= requestedCount) {
            return info.fColorSampleCounts[i];
        }
    }
    return 0;
}

◆ GetStencilFormatTotalBitCount()

static int GrVkCaps::GetStencilFormatTotalBitCount ( VkFormat format )

inlinestatic

Definition at line 107 of file GrVkCaps.h.

                                                              {
        switch (format) {
            case VK_FORMAT_S8_UINT:
                return 8;
            case VK_FORMAT_D24_UNORM_S8_UINT:
                return 32;
            case VK_FORMAT_D32_SFLOAT_S8_UINT:
                // can optionally have 24 unused bits at the end so we assume the total bits is 64.
                return 64;
            default:
                SkASSERT(false);
                return 0;
        }
    }

◆ getWriteSwizzle()

skgpu::Swizzle GrVkCaps::getWriteSwizzle	(	const GrBackendFormat &	,
		GrColorType
	)		const

overridevirtual

Returns the skgpu::Swizzle to use when writing colors to a surface with the passed in GrBackendFormat and GrColorType.

Implements GrCaps.

Definition at line 1849 of file GrVkCaps.cpp.

                                                                      {
    VkFormat vkFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(format, &vkFormat));
    const auto& info = this->getFormatInfo(vkFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        const auto& ctInfo = info.fColorTypeInfos[i];
        if (ctInfo.fColorType == colorType) {
            return ctInfo.fWriteSwizzle;
        }
    }
    SkDEBUGFAILF("Illegal color type (%d) and format (%d) combination.",
                 (int)colorType, (int)vkFormat);
    return {};
}

◆ gpuOnlyBuffersMorePerformant()

bool GrVkCaps::gpuOnlyBuffersMorePerformant ( ) const

inline

Definition at line 193 of file GrVkCaps.h.

193{ return fGpuOnlyBuffersMorePerformant; }

◆ isFormatAsColorTypeRenderable()

bool GrVkCaps::isFormatAsColorTypeRenderable	(	GrColorType	ct,
		const GrBackendFormat &	format,
		int	sampleCount = `1`
	)		const

overridevirtual

Implements GrCaps.

Definition at line 1569 of file GrVkCaps.cpp.

                                                                    {
    if (!this->isFormatRenderable(format, sampleCount)) {
        return false;
    }
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return false;
    }
    const auto& info = this->getFormatInfo(vkFormat);
    if (!SkToBool(info.colorTypeFlags(ct) & ColorTypeInfo::kRenderable_Flag)) {
        return false;
    }
    return true;
}

◆ isFormatCopyable()

bool GrVkCaps::isFormatCopyable ( const GrBackendFormat & ) const

inlineoverridevirtual

Implements GrCaps.

Definition at line 47 of file GrVkCaps.h.

47{ return true; }

◆ isFormatRenderable() [1/2]

bool GrVkCaps::isFormatRenderable	(	const GrBackendFormat &	format,
		int	sampleCount
	)		const

overridevirtual

Implements GrCaps.

Definition at line 1585 of file GrVkCaps.cpp.

                                                                                      {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return false;
    }
    return this->isFormatRenderable(vkFormat, sampleCount);
}

◆ isFormatRenderable() [2/2]

bool GrVkCaps::isFormatRenderable	(	VkFormat	format,
		int	sampleCount
	)		const

Definition at line 1593 of file GrVkCaps.cpp.

                                                                        {
    return sampleCount <= this->maxRenderTargetSampleCount(format);
}

◆ isFormatSRGB()

bool GrVkCaps::isFormatSRGB ( const GrBackendFormat & format ) const

overridevirtual

Implements GrCaps.

Definition at line 1539 of file GrVkCaps.cpp.

                                                               {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return false;
    }
    if (backend_format_is_external(format)) {
        return false;
    }
 
    return format_is_srgb(vkFormat);
}

◆ isFormatTexturable()

bool GrVkCaps::isFormatTexturable	(	const GrBackendFormat &	format,
		GrTextureType
	)		const

overridevirtual

Implements GrCaps.

Definition at line 1551 of file GrVkCaps.cpp.

                                                                                    {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return false;
    }
    if (backend_format_is_external(format)) {
        // We can always texture from an external format (assuming we have the ycbcr conversion
        // info which we require to be passed in).
        return true;
    }
    return this->isVkFormatTexturable(vkFormat);
}

◆ isVkFormatTexturable()

bool GrVkCaps::isVkFormatTexturable ( VkFormat format ) const

Definition at line 1564 of file GrVkCaps.cpp.

                                                         {
    const FormatInfo& info = this->getFormatInfo(format);
    return SkToBool(FormatInfo::kTexturable_Flag & info.fOptimalFlags);
}

◆ isVkFormatTexturableLinearly()

bool GrVkCaps::isVkFormatTexturableLinearly ( VkFormat format ) const

inline

Definition at line 67 of file GrVkCaps.h.

                                                             {
        return SkToBool(FormatInfo::kTexturable_Flag & this->getFormatInfo(format).fLinearFlags);
    }

◆ makeDesc()

GrProgramDesc GrVkCaps::makeDesc	(	GrRenderTarget *	rt,
		const GrProgramInfo &	programInfo,
		ProgramDescOverrideFlags	overrideFlags
	)		const

overridevirtual

For Vulkan we want to cache the entire VkPipeline for reuse of draws. The Desc here holds all the information needed to differentiate one pipeline from another.

The GrProgramDesc contains all the information need to create the actual shaders for the pipeline.

For Vulkan we need to add to the GrProgramDesc to include the rest of the state on the pipline. This includes stencil settings, blending information, render pass format, draw face information, and primitive type. Note that some state is set dynamically on the pipeline for each draw and thus is not included in this descriptor. This includes the viewport, scissor, and blend constant.

Implements GrCaps.

Definition at line 1962 of file GrVkCaps.cpp.

                                                                               {
    GrProgramDesc desc;
    GrProgramDesc::Build(&desc, programInfo, *this);
 
    skgpu::KeyBuilder b(desc.key());
 
    // This will become part of the sheared off key used to persistently cache
    // the SPIRV code. It needs to be added right after the base key so that,
    // when the base-key is sheared off, the shearing code can include it in the
    // reduced key (c.f. the +4s in the SkData::MakeWithCopy calls in
    // GrVkPipelineStateBuilder.cpp).
    b.add32(GrVkGpu::kShader_PersistentCacheKeyType);
 
    GrVkRenderPass::SelfDependencyFlags selfDepFlags = GrVkRenderPass::SelfDependencyFlags::kNone;
    if (programInfo.renderPassBarriers() & GrXferBarrierFlags::kBlend) {
        selfDepFlags |= GrVkRenderPass::SelfDependencyFlags::kForNonCoherentAdvBlend;
    }
    if (programInfo.renderPassBarriers() & GrXferBarrierFlags::kTexture) {
        selfDepFlags |= GrVkRenderPass::SelfDependencyFlags::kForInputAttachment;
    }
 
    bool needsResolve = this->programInfoWillUseDiscardableMSAA(programInfo);
 
    bool forceLoadFromResolve =
            overrideFlags & GrCaps::ProgramDescOverrideFlags::kVulkanHasResolveLoadSubpass;
    SkASSERT(!forceLoadFromResolve || needsResolve);
 
    GrVkRenderPass::LoadFromResolve loadFromResolve = GrVkRenderPass::LoadFromResolve::kNo;
    if (needsResolve && (programInfo.colorLoadOp() == GrLoadOp::kLoad || forceLoadFromResolve)) {
        loadFromResolve = GrVkRenderPass::LoadFromResolve::kLoad;
    }
 
    if (rt) {
        GrVkRenderTarget* vkRT = (GrVkRenderTarget*) rt;
 
        SkASSERT(!needsResolve || (vkRT->resolveAttachment() &&
                                   vkRT->resolveAttachment()->supportsInputAttachmentUsage()));
 
        bool needsStencil = programInfo.needsStencil() || programInfo.isStencilEnabled();
        // TODO: support failure in getSimpleRenderPass
        auto rp = vkRT->getSimpleRenderPass(needsResolve, needsStencil, selfDepFlags,
                                            loadFromResolve);
        SkASSERT(rp);
        rp->genKey(&b);
 
#ifdef SK_DEBUG
        if (!rp->isExternal()) {
            // This is to ensure ReconstructAttachmentsDescriptor keeps matching
            // getSimpleRenderPass' result
            GrVkRenderPass::AttachmentsDescriptor attachmentsDescriptor;
            GrVkRenderPass::AttachmentFlags attachmentFlags;
            GrVkRenderTarget::ReconstructAttachmentsDescriptor(*this, programInfo,
                                                               &attachmentsDescriptor,
                                                               &attachmentFlags);
            SkASSERT(rp->isCompatible(attachmentsDescriptor, attachmentFlags, selfDepFlags,
                                      loadFromResolve));
        }
#endif
    } else {
        GrVkRenderPass::AttachmentsDescriptor attachmentsDescriptor;
        GrVkRenderPass::AttachmentFlags attachmentFlags;
        GrVkRenderTarget::ReconstructAttachmentsDescriptor(*this, programInfo,
                                                           &attachmentsDescriptor,
                                                           &attachmentFlags);
 
        // kExternal_AttachmentFlag is only set for wrapped secondary command buffers - which
        // will always go through the above 'rt' path (i.e., we can always pass 0 as the final
        // parameter to GenKey).
        GrVkRenderPass::GenKey(&b, attachmentFlags, attachmentsDescriptor, selfDepFlags,
                               loadFromResolve, 0);
    }
 
    GrStencilSettings stencil = programInfo.nonGLStencilSettings();
    stencil.genKey(&b, true);
 
    programInfo.pipeline().genKey(&b, *this);
    b.add32(programInfo.numSamples());
 
    // Vulkan requires the full primitive type as part of its key
    b.add32(programInfo.primitiveTypeKey());
 
    b.flush();
    return desc;
}

◆ maxDrawIndirectDrawCount()

uint32_t GrVkCaps::maxDrawIndirectDrawCount ( ) const

inline

Definition at line 203 of file GrVkCaps.h.

203{ return fMaxDrawIndirectDrawCount; }

◆ maxInputAttachmentDescriptors()

uint32_t GrVkCaps::maxInputAttachmentDescriptors ( ) const

inline

Definition at line 181 of file GrVkCaps.h.

181{ return fMaxInputAttachmentDescriptors; }

◆ maxPerPoolCachedSecondaryCommandBuffers()

int GrVkCaps::maxPerPoolCachedSecondaryCommandBuffers ( ) const

inline

Definition at line 177 of file GrVkCaps.h.

                                                        {
        return fMaxPerPoolCachedSecondaryCommandBuffers;
    }

◆ maxRenderTargetSampleCount() [1/2]

int GrVkCaps::maxRenderTargetSampleCount ( const GrBackendFormat & format ) const

overridevirtual

Implements GrCaps.

Definition at line 1631 of file GrVkCaps.cpp.

                                                                            {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return 0;
    }
    return this->maxRenderTargetSampleCount(vkFormat);
}

◆ maxRenderTargetSampleCount() [2/2]

int GrVkCaps::maxRenderTargetSampleCount ( VkFormat format ) const

Definition at line 1639 of file GrVkCaps.cpp.

                                                              {
    const FormatInfo& info = this->getFormatInfo(format);
 
    const auto& table = info.fColorSampleCounts;
    if (table.empty()) {
        return 0;
    }
    return table[table.size() - 1];
}

◆ maxSamplerAnisotropy()

float GrVkCaps::maxSamplerAnisotropy ( ) const

inline

Definition at line 183 of file GrVkCaps.h.

183{ return fMaxSamplerAnisotropy; }

◆ mustInvalidatePrimaryCmdBufferStateAfterClearAttachments()

bool GrVkCaps::mustInvalidatePrimaryCmdBufferStateAfterClearAttachments ( ) const

inline

Definition at line 185 of file GrVkCaps.h.

                                                                          {
        return fMustInvalidatePrimaryCmdBufferStateAfterClearAttachments;
    }

◆ mustLoadFullImageWithDiscardableMSAA()

bool GrVkCaps::mustLoadFullImageWithDiscardableMSAA ( ) const

inline

Definition at line 259 of file GrVkCaps.h.

                                                      {
        return fMustLoadFullImageWithDiscardableMSAA;
    }

◆ mustSyncCommandBuffersWithQueue()

bool GrVkCaps::mustSyncCommandBuffersWithQueue ( ) const

inline

Definition at line 91 of file GrVkCaps.h.

91{ return fMustSyncCommandBuffersWithQueue; }

◆ onAreColorTypeAndFormatCompatible()

bool GrVkCaps::onAreColorTypeAndFormatCompatible	(	GrColorType	ct,
		const GrBackendFormat &	format
	)		const

overrideprivatevirtual

Implements GrCaps.

Definition at line 1743 of file GrVkCaps.cpp.

                                                                                      {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(format, &vkFormat)) {
        return false;
    }
    const GrVkYcbcrConversionInfo* ycbcrInfo = GrBackendFormats::GetVkYcbcrConversionInfo(format);
    SkASSERT(ycbcrInfo);
 
    if (ycbcrInfo->isValid() && !skgpu::VkFormatNeedsYcbcrSampler(vkFormat)) {
        // Format may be undefined for external images, which are required to have YCbCr conversion.
        if (VK_FORMAT_UNDEFINED == vkFormat && ycbcrInfo->fExternalFormat != 0) {
            return true;
        }
        return false;
    }
 
    const auto& info = this->getFormatInfo(vkFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        if (info.fColorTypeInfos[i].fColorType == ct) {
            return true;
        }
    }
    return false;
}

◆ onCanCopySurface()

bool GrVkCaps::onCanCopySurface	(	const GrSurfaceProxy *	dst,
		const SkIRect &	dstRect,
		const GrSurfaceProxy *	src,
		const SkIRect &	srcRect
	)		const

overrideprivatevirtual

Implements GrCaps.

Definition at line 216 of file GrVkCaps.cpp.

                                                                                         {
    if (src->isProtected() == GrProtected::kYes && dst->isProtected() != GrProtected::kYes) {
        return false;
    }
 
    // TODO: Figure out a way to track if we've wrapped a linear texture in a proxy (e.g.
    // PromiseImage which won't get instantiated right away. Does this need a similar thing like the
    // tracking of external or rectangle textures in GL? For now we don't create linear textures
    // internally, and I don't believe anyone is wrapping them.
    bool srcIsLinear = false;
    bool dstIsLinear = false;
 
    int dstSampleCnt = 0;
    int srcSampleCnt = 0;
    if (const GrRenderTargetProxy* rtProxy = dst->asRenderTargetProxy()) {
        // Copying to or from render targets that wrap a secondary command buffer is not allowed
        // since they would require us to know the VkImage, which we don't have, as well as need us
        // to stop and start the VkRenderPass which we don't have access to.
        if (rtProxy->wrapsVkSecondaryCB()) {
            return false;
        }
        if (this->preferDiscardableMSAAAttachment() && dst->asTextureProxy() &&
            rtProxy->supportsVkInputAttachment()) {
            dstSampleCnt = 1;
        } else {
            dstSampleCnt = rtProxy->numSamples();
        }
    }
    if (const GrRenderTargetProxy* rtProxy = src->asRenderTargetProxy()) {
        // Copying to or from render targets that wrap a secondary command buffer is not allowed
        // since they would require us to know the VkImage, which we don't have, as well as need us
        // to stop and start the VkRenderPass which we don't have access to.
        if (rtProxy->wrapsVkSecondaryCB()) {
            return false;
        }
        if (this->preferDiscardableMSAAAttachment() && src->asTextureProxy() &&
            rtProxy->supportsVkInputAttachment()) {
            srcSampleCnt = 1;
        } else {
            srcSampleCnt = rtProxy->numSamples();
        }
    }
    SkASSERT((dstSampleCnt > 0) == SkToBool(dst->asRenderTargetProxy()));
    SkASSERT((srcSampleCnt > 0) == SkToBool(src->asRenderTargetProxy()));
 
    bool dstHasYcbcr = false;
    if (auto ycbcr = GrBackendFormats::GetVkYcbcrConversionInfo(dst->backendFormat())) {
        if (ycbcr->isValid()) {
            dstHasYcbcr = true;
        }
    }
 
    bool srcHasYcbcr = false;
    if (auto ycbcr = GrBackendFormats::GetVkYcbcrConversionInfo(src->backendFormat())) {
        if (ycbcr->isValid()) {
            srcHasYcbcr = true;
        }
    }
 
    VkFormat dstFormat, srcFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(dst->backendFormat(), &dstFormat));
    SkAssertResult(GrBackendFormats::AsVkFormat(src->backendFormat(), &srcFormat));
 
    // Only blits support scaling, but since we've already clamped the src and dst rects,
    // the dimensions of the scaled blit aren't important to know if it's allowed.
    const bool copyScales = srcRect.size() != dstRect.size();
    if (!copyScales && (this->canCopyImage(dstFormat, dstSampleCnt, dstHasYcbcr,
                                           srcFormat, srcSampleCnt, srcHasYcbcr) ||
                        this->canCopyAsResolve(dstFormat, dstSampleCnt, dstHasYcbcr,
                                               srcFormat, srcSampleCnt, srcHasYcbcr))) {
        return true;
    }
    return this->canCopyAsBlit(dstFormat, dstSampleCnt, dstIsLinear, dstHasYcbcr,
                               srcFormat, srcSampleCnt, srcIsLinear, srcHasYcbcr);
 
}

◆ onGetDefaultBackendFormat()

GrBackendFormat GrVkCaps::onGetDefaultBackendFormat ( GrColorType ct ) const

overrideprivatevirtual

Implements GrCaps.

Definition at line 1769 of file GrVkCaps.cpp.

                                                                        {
    VkFormat format = this->getFormatFromColorType(ct);
    if (format == VK_FORMAT_UNDEFINED) {
        return {};
    }
    return GrBackendFormats::MakeVk(format);
}

◆ onGetDstSampleFlagsForProxy()

GrDstSampleFlags GrVkCaps::onGetDstSampleFlagsForProxy ( const GrRenderTargetProxy * rt ) const

overrideprivatevirtual

Reimplemented from GrCaps.

Definition at line 1865 of file GrVkCaps.cpp.

                                                                                          {
    bool isMSAAWithResolve = rt->numSamples() > 1 && rt->asTextureProxy();
    // TODO: Currently if we have an msaa rt with a resolve, the supportsVkInputAttachment call
    // references whether the resolve is supported as an input attachment. We need to add a check to
    // allow checking the color attachment (msaa or not) supports input attachment specifically.
    if (!isMSAAWithResolve && rt->supportsVkInputAttachment()) {
        return GrDstSampleFlags::kRequiresTextureBarrier | GrDstSampleFlags::kAsInputAttachment;
    }
    return GrDstSampleFlags::kNone;
}

◆ onGetReadSwizzle()

skgpu::Swizzle GrVkCaps::onGetReadSwizzle	(	const GrBackendFormat &	format,
		GrColorType	colorType
	)		const

overrideprivatevirtual

Implements GrCaps.

Definition at line 1825 of file GrVkCaps.cpp.

                                                                       {
    VkFormat vkFormat;
    SkAssertResult(GrBackendFormats::AsVkFormat(format, &vkFormat));
    const GrVkYcbcrConversionInfo* ycbcrInfo = GrBackendFormats::GetVkYcbcrConversionInfo(format);
    SkASSERT(ycbcrInfo);
    if (ycbcrInfo->isValid() && ycbcrInfo->fExternalFormat != 0) {
        // We allow these to work with any color type and never swizzle. See
        // onAreColorTypeAndFormatCompatible.
        return skgpu::Swizzle{"rgba"};
    }
 
    const auto& info = this->getFormatInfo(vkFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        const auto& ctInfo = info.fColorTypeInfos[i];
        if (ctInfo.fColorType == colorType) {
            return ctInfo.fReadSwizzle;
        }
    }
    SkDEBUGFAILF("Illegal color type (%d) and format (%d) combination.",
                 (int)colorType, (int)vkFormat);
    return {};
}

◆ onSupportedReadPixelsColorType()

GrCaps::SupportedRead GrVkCaps::onSupportedReadPixelsColorType	(	GrColorType	srcColorType,
		const GrBackendFormat &	srcBackendFormat,
		GrColorType	dstColorType
	)		const

overrideprivatevirtual

Implements GrCaps.

Definition at line 1891 of file GrVkCaps.cpp.

                                        {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(srcBackendFormat, &vkFormat)) {
        return {GrColorType::kUnknown, 0};
    }
 
    if (skgpu::VkFormatNeedsYcbcrSampler(vkFormat)) {
        return {GrColorType::kUnknown, 0};
    }
 
    SkTextureCompressionType compression = GrBackendFormatToCompressionType(srcBackendFormat);
    if (compression != SkTextureCompressionType::kNone) {
        return { SkTextureCompressionTypeIsOpaque(compression) ? GrColorType::kRGB_888x
                                                        : GrColorType::kRGBA_8888, 0 };
    }
 
    // The VkBufferImageCopy bufferOffset field must be both a multiple of 4 and of a single texel.
    size_t offsetAlignment = align_to_4(skgpu::VkFormatBytesPerBlock(vkFormat));
 
    const auto& info = this->getFormatInfo(vkFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        const auto& ctInfo = info.fColorTypeInfos[i];
        if (ctInfo.fColorType == srcColorType) {
            return {ctInfo.fTransferColorType, offsetAlignment};
        }
    }
    return {GrColorType::kUnknown, 0};
}

◆ onSupportsDynamicMSAA()

bool GrVkCaps::onSupportsDynamicMSAA ( const GrRenderTargetProxy * rtProxy ) const

overrideprivatevirtual

Reimplemented from GrCaps.

Definition at line 1777 of file GrVkCaps.cpp.

                                                                             {
    // We must be able to use the rtProxy as an input attachment to load into the discardable msaa
    // attachment. Also the rtProxy should have a sample count of 1 so that it can be used as a
    // resolve attachment.
    return this->supportsDiscardableMSAAForDMSAA() &&
           rtProxy->supportsVkInputAttachment() &&
           rtProxy->numSamples() == 1;
}

◆ onSurfaceSupportsWritePixels()

bool GrVkCaps::onSurfaceSupportsWritePixels ( const GrSurface * surface ) const

overrideprivatevirtual

Implements GrCaps.

Definition at line 1725 of file GrVkCaps.cpp.

                                                                          {
    if (auto rt = surface->asRenderTarget()) {
        return rt->numSamples() <= 1 && SkToBool(surface->asTexture());
    }
    // We can't write to a texture that has a ycbcr sampler.
    if (auto tex = static_cast<const GrVkTexture*>(surface->asTexture())) {
        auto texImage = tex->textureImage();
        if (!texImage) {
            return false;
        }
        // We can't directly read from a VkImage that has a ycbcr sampler.
        if (texImage->ycbcrConversionInfo().isValid()) {
            return false;
        }
    }
    return true;
}

◆ preferPrimaryOverSecondaryCommandBuffers()

bool GrVkCaps::preferPrimaryOverSecondaryCommandBuffers ( ) const

inline

Definition at line 173 of file GrVkCaps.h.

                                                          {
        return fPreferPrimaryOverSecondaryCommandBuffers;
    }

◆ preferredStencilFormat()

VkFormat GrVkCaps::preferredStencilFormat ( ) const

inline

Returns both a supported and most preferred stencil format to use in draws.

Definition at line 104 of file GrVkCaps.h.

104{ return fPreferredStencilFormat; }

◆ programInfoWillUseDiscardableMSAA()

bool GrVkCaps::programInfoWillUseDiscardableMSAA ( const GrProgramInfo & programInfo ) const

Definition at line 1793 of file GrVkCaps.cpp.

                                                                                       {
    return programInfo.targetHasVkResolveAttachmentWithInput() &&
           programInfo.numSamples() > 1 &&
           ((programInfo.targetsNumSamples() > 1 && this->preferDiscardableMSAAAttachment()) ||
            (programInfo.targetsNumSamples() == 1 && this->supportsDiscardableMSAAForDMSAA()));
}

◆ renderTargetSupportsDiscardableMSAA()

bool GrVkCaps::renderTargetSupportsDiscardableMSAA ( const GrVkRenderTarget * rt ) const

Definition at line 1786 of file GrVkCaps.cpp.

                                                                                   {
    return rt->resolveAttachment() &&
           rt->resolveAttachment()->supportsInputAttachmentUsage() &&
           ((rt->numSamples() > 1 && this->preferDiscardableMSAAAttachment()) ||
            (rt->numSamples() == 1 && this->supportsDiscardableMSAAForDMSAA()));
}

◆ shouldAlwaysUseDedicatedImageMemory()

bool GrVkCaps::shouldAlwaysUseDedicatedImageMemory ( ) const

inline

Definition at line 94 of file GrVkCaps.h.

                                                     {
        return fShouldAlwaysUseDedicatedImageMemory;
    }

◆ shouldPersistentlyMapCpuToGpuBuffers()

bool GrVkCaps::shouldPersistentlyMapCpuToGpuBuffers ( ) const

inline

Definition at line 198 of file GrVkCaps.h.

                                                      {
        return fShouldPersistentlyMapCpuToGpuBuffers;
    }

◆ supportedWritePixelsColorType()

GrCaps::SupportedWrite GrVkCaps::supportedWritePixelsColorType	(	GrColorType	surfaceColorType,
		const GrBackendFormat &	surfaceFormat,
		GrColorType	srcColorType
	)		const

overridevirtual

Given a dst pixel config and a src color type what color type must the caller coax the the data into in order to use GrGpu::writePixels().

Implements GrCaps.

Definition at line 1660 of file GrVkCaps.cpp.

                                                                                               {
    VkFormat vkFormat;
    if (!GrBackendFormats::AsVkFormat(surfaceFormat, &vkFormat)) {
        return {GrColorType::kUnknown, 0};
    }
 
    // We don't support the ability to upload to external formats or formats that require a ycbcr
    // sampler. In general these types of formats are only used for sampling in a shader.
    if (backend_format_is_external(surfaceFormat) || skgpu::VkFormatNeedsYcbcrSampler(vkFormat)) {
        return {GrColorType::kUnknown, 0};
    }
 
    // The VkBufferImageCopy bufferOffset field must be both a multiple of 4 and of a single texel.
    size_t offsetAlignment = align_to_4(skgpu::VkFormatBytesPerBlock(vkFormat));
 
    const auto& info = this->getFormatInfo(vkFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        const auto& ctInfo = info.fColorTypeInfos[i];
        if (ctInfo.fColorType == surfaceColorType) {
            return {ctInfo.fTransferColorType, offsetAlignment};
        }
    }
    return {GrColorType::kUnknown, 0};
}

◆ supportsAndroidHWBExternalMemory()

bool GrVkCaps::supportsAndroidHWBExternalMemory ( ) const

inline

Definition at line 150 of file GrVkCaps.h.

150{ return fSupportsAndroidHWBExternalMemory; }

◆ supportsBindMemory2()

bool GrVkCaps::supportsBindMemory2 ( ) const

inline

Definition at line 134 of file GrVkCaps.h.

134{ return fSupportsBindMemory2; }

◆ supportsDedicatedAllocation()

bool GrVkCaps::supportsDedicatedAllocation ( ) const

inline

Definition at line 145 of file GrVkCaps.h.

145{ return fSupportsDedicatedAllocation; }

◆ supportsDeviceFaultInfo()

bool GrVkCaps::supportsDeviceFaultInfo ( ) const

inline

Definition at line 170 of file GrVkCaps.h.

170{ return fSupportsDeviceFaultInfo; }

◆ supportsDiscardableMSAAForDMSAA()

bool GrVkCaps::supportsDiscardableMSAAForDMSAA ( ) const

inline

Definition at line 262 of file GrVkCaps.h.

262{ return fSupportsDiscardableMSAAForDMSAA; }

◆ supportsDRMFormatModifiers()

bool GrVkCaps::supportsDRMFormatModifiers ( ) const

inline

Definition at line 168 of file GrVkCaps.h.

168{ return fSupportsDRMFormatModifiers; }

◆ supportsExternalMemory()

bool GrVkCaps::supportsExternalMemory ( ) const

inline

Definition at line 148 of file GrVkCaps.h.

148{ return fSupportsExternalMemory; }

◆ supportsMaintenance1()

bool GrVkCaps::supportsMaintenance1 ( ) const

inline

Definition at line 138 of file GrVkCaps.h.

138{ return fSupportsMaintenance1; }

◆ supportsMaintenance2()

bool GrVkCaps::supportsMaintenance2 ( ) const

inline

Definition at line 139 of file GrVkCaps.h.

139{ return fSupportsMaintenance2; }

◆ supportsMaintenance3()

bool GrVkCaps::supportsMaintenance3 ( ) const

inline

Definition at line 140 of file GrVkCaps.h.

140{ return fSupportsMaintenance3; }

◆ supportsMemorylessAttachments()

bool GrVkCaps::supportsMemorylessAttachments ( ) const

inline

Definition at line 268 of file GrVkCaps.h.

268{ return fSupportsMemorylessAttachments; }

◆ supportsMemoryRequirements2()

bool GrVkCaps::supportsMemoryRequirements2 ( ) const

inline

Definition at line 131 of file GrVkCaps.h.

131{ return fSupportsMemoryRequirements2; }

◆ supportsPhysicalDeviceProperties2()

bool GrVkCaps::supportsPhysicalDeviceProperties2 ( ) const

inline

Definition at line 129 of file GrVkCaps.h.

129{ return fSupportsPhysicalDeviceProperties2; }

◆ supportsSwapchain()

bool GrVkCaps::supportsSwapchain ( ) const

inline

Definition at line 126 of file GrVkCaps.h.

126{ return fSupportsSwapchain; }

◆ supportsYcbcrConversion()

bool GrVkCaps::supportsYcbcrConversion ( ) const

inline

Definition at line 153 of file GrVkCaps.h.

153{ return fSupportsYcbcrConversion; }

◆ surfaceSupportsReadPixels()

GrCaps::SurfaceReadPixelsSupport GrVkCaps::surfaceSupportsReadPixels ( const GrSurface * ) const

overridevirtual

Backends may have restrictions on what types of surfaces support GrGpu::readPixels(). We may either be able to read directly from the surface, read from a copy of the surface, or not read at all.

Implements GrCaps.

Definition at line 1687 of file GrVkCaps.cpp.

                                        {
    if (surface->isProtected()) {
        return SurfaceReadPixelsSupport::kUnsupported;
    }
    if (auto tex = static_cast<const GrVkTexture*>(surface->asTexture())) {
        auto texImage = tex->textureImage();
        if (!texImage) {
            return SurfaceReadPixelsSupport::kUnsupported;
        }
        // We can't directly read from a VkImage that has a ycbcr sampler.
        if (texImage->ycbcrConversionInfo().isValid()) {
            return SurfaceReadPixelsSupport::kCopyToTexture2D;
        }
        // We can't directly read from a compressed format
        if (skgpu::VkFormatIsCompressed(texImage->imageFormat())) {
            return SurfaceReadPixelsSupport::kCopyToTexture2D;
        }
        return SurfaceReadPixelsSupport::kSupported;
    } else if (auto rt = surface->asRenderTarget()) {
        if (rt->numSamples() > 1) {
            return SurfaceReadPixelsSupport::kCopyToTexture2D;
        }
        return SurfaceReadPixelsSupport::kSupported;
    }
    return SurfaceReadPixelsSupport::kUnsupported;
}

◆ transferColorType()

GrColorType GrVkCaps::transferColorType	(	VkFormat	vkFormat,
		GrColorType	surfaceColorType
	)		const

Definition at line 1715 of file GrVkCaps.cpp.

                                                                                             {
    const auto& info = this->getFormatInfo(vkFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        if (info.fColorTypeInfos[i].fColorType == surfaceColorType) {
            return info.fColorTypeInfos[i].fTransferColorType;
        }
    }
    return GrColorType::kUnknown;
}

◆ ycbcrCombinedImageSamplerDescriptorCount()

uint32_t GrVkCaps::ycbcrCombinedImageSamplerDescriptorCount ( ) const

inline

Definition at line 163 of file GrVkCaps.h.

                                                              {
        return 3;
    }

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

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GrVkCaps()

Member Function Documentation

◆ addExtraSamplerKey()

◆ avoidUpdateBuffers()

◆ canCopyAsBlit()

◆ canCopyAsResolve()

◆ canCopyImage()

◆ computeFormatKey()

◆ dmsaaResolveCanBeUsedAsTextureInSameRenderPass()

◆ formatCanBeDstofBlit()

◆ formatCanBeSrcofBlit()

◆ getBackendFormatFromCompressionType()

◆ getExtraSurfaceFlagsForDeferredRT()

◆ getFormatFromColorType()

◆ getFragmentUniformBinding()

◆ getFragmentUniformSet()

◆ getPushConstantStageFlags()

◆ getRenderTargetSampleCount() [1/2]

◆ getRenderTargetSampleCount() [2/2]

◆ GetStencilFormatTotalBitCount()

◆ getWriteSwizzle()

◆ gpuOnlyBuffersMorePerformant()

◆ isFormatAsColorTypeRenderable()

◆ isFormatCopyable()

◆ isFormatRenderable() [1/2]

◆ isFormatRenderable() [2/2]

◆ isFormatSRGB()

◆ isFormatTexturable()

◆ isVkFormatTexturable()

◆ isVkFormatTexturableLinearly()

◆ makeDesc()

◆ maxDrawIndirectDrawCount()

◆ maxInputAttachmentDescriptors()

◆ maxPerPoolCachedSecondaryCommandBuffers()

◆ maxRenderTargetSampleCount() [1/2]

◆ maxRenderTargetSampleCount() [2/2]

◆ maxSamplerAnisotropy()

◆ mustInvalidatePrimaryCmdBufferStateAfterClearAttachments()

◆ mustLoadFullImageWithDiscardableMSAA()

◆ mustSyncCommandBuffersWithQueue()

◆ onAreColorTypeAndFormatCompatible()

◆ onCanCopySurface()

◆ onGetDefaultBackendFormat()

◆ onGetDstSampleFlagsForProxy()

◆ onGetReadSwizzle()

◆ onSupportedReadPixelsColorType()

◆ onSupportsDynamicMSAA()

◆ onSurfaceSupportsWritePixels()

◆ preferPrimaryOverSecondaryCommandBuffers()

◆ preferredStencilFormat()

◆ programInfoWillUseDiscardableMSAA()

◆ renderTargetSupportsDiscardableMSAA()

◆ shouldAlwaysUseDedicatedImageMemory()

◆ shouldPersistentlyMapCpuToGpuBuffers()

◆ supportedWritePixelsColorType()

◆ supportsAndroidHWBExternalMemory()

◆ supportsBindMemory2()

◆ supportsDedicatedAllocation()

◆ supportsDeviceFaultInfo()

◆ supportsDiscardableMSAAForDMSAA()

◆ supportsDRMFormatModifiers()

◆ supportsExternalMemory()

◆ supportsMaintenance1()

◆ supportsMaintenance2()

◆ supportsMaintenance3()

◆ supportsMemorylessAttachments()

◆ supportsMemoryRequirements2()

◆ supportsPhysicalDeviceProperties2()

◆ supportsSwapchain()

◆ supportsYcbcrConversion()

◆ surfaceSupportsReadPixels()

◆ transferColorType()

◆ ycbcrCombinedImageSamplerDescriptorCount()