#include <DawnCaps.h>

Inheritance diagram for skgpu::graphite::DawnCaps:

Public Member Functions
	DawnCaps (const DawnBackendContext &, const ContextOptions &)

	~DawnCaps () override

bool	useAsyncPipelineCreation () const

bool	allowScopedErrorChecks () const

TextureInfo	getDefaultSampledTextureInfo (SkColorType, Mipmapped mipmapped, Protected, Renderable) const override

TextureInfo	getTextureInfoForSampledCopy (const TextureInfo &textureInfo, Mipmapped mipmapped) const override

TextureInfo	getDefaultCompressedTextureInfo (SkTextureCompressionType, Mipmapped mipmapped, Protected) const override

TextureInfo	getDefaultMSAATextureInfo (const TextureInfo &singleSampledInfo, Discardable discardable) const override

TextureInfo	getDefaultDepthStencilTextureInfo (SkEnumBitMask< DepthStencilFlags >, uint32_t sampleCount, Protected) const override

TextureInfo	getDefaultStorageTextureInfo (SkColorType) const override

SkISize	getDepthAttachmentDimensions (const TextureInfo &, const SkISize colorAttachmentDimensions) const override

UniqueKey	makeGraphicsPipelineKey (const GraphicsPipelineDesc &, const RenderPassDesc &) const override

UniqueKey	makeComputePipelineKey (const ComputePipelineDesc &) const override

uint32_t	channelMask (const TextureInfo &) const override

bool	isRenderable (const TextureInfo &) const override

bool	isStorage (const TextureInfo &) const override

void	buildKeyForTexture (SkISize dimensions, const TextureInfo &, ResourceType, Shareable, GraphiteResourceKey *) const override

uint64_t	getRenderPassDescKey (const RenderPassDesc &renderPassDesc) const

Public Member Functions inherited from skgpu::graphite::Caps
virtual	~Caps ()

const SkSL::ShaderCaps *	shaderCaps () const

sk_sp< SkCapabilities >	capabilities () const

virtual GraphiteResourceKey	makeSamplerKey (const SamplerDesc &samplerDesc) const

virtual bool	extractGraphicsDescs (const UniqueKey &, GraphicsPipelineDesc , RenderPassDesc , const RendererProvider *) const

bool	areColorTypeAndTextureInfoCompatible (SkColorType, const TextureInfo &) const

bool	isTexturable (const TextureInfo &) const

int	maxTextureSize () const

int	defaultMSAASamplesCount () const

const ResourceBindingRequirements &	resourceBindingRequirements () const

size_t	requiredUniformBufferAlignment () const

size_t	requiredStorageBufferAlignment () const

size_t	requiredTransferBufferAlignment () const

size_t	getAlignedTextureDataRowBytes (size_t rowBytes) const

SkColorType	getRenderableColorType (SkColorType) const

bool	clampToBorderSupport () const

bool	protectedSupport () const

bool	semaphoreSupport () const

bool	allowCpuSync () const

bool	storageBufferSupport () const

bool	storageBufferPreferred () const

bool	drawBufferCanBeMapped () const

bool	bufferMapsAreAsync () const

bool	msaaRenderToSingleSampledSupport () const

bool	computeSupport () const

bool	supportsAHardwareBufferImages () const

skgpu::Swizzle	getReadSwizzle (SkColorType, const TextureInfo &) const

skgpu::Swizzle	getWriteSwizzle (SkColorType, const TextureInfo &) const

skgpu::ShaderErrorHandler *	shaderErrorHandler () const

DstReadRequirement	getDstReadRequirement () const

float	minDistanceFieldFontSize () const

float	glyphsAsPathsFontSize () const

size_t	glyphCacheTextureMaximumBytes () const

int	maxPathAtlasTextureSize () const

bool	allowMultipleAtlasTextures () const

bool	supportBilerpFromGlyphAtlas () const

bool	requireOrderedRecordings () const

bool	fullCompressedUploadSizeMustAlignToBlockDims () const

sktext::gpu::SDFTControl	getSDFTControl (bool useSDFTForSmallText) const

Static Public Attributes
static constexpr size_t	kFormatCnt = 16

Private Member Functions
const ColorTypeInfo *	getColorTypeInfo (SkColorType, const TextureInfo &) const override

bool	onIsTexturable (const TextureInfo &) const override

bool	supportsWritePixels (const TextureInfo &textureInfo) const override

bool	supportsReadPixels (const TextureInfo &textureInfo) const override

std::pair< SkColorType, bool >	supportedWritePixelsColorType (SkColorType dstColorType, const TextureInfo &dstTextureInfo, SkColorType srcColorType) const override

std::pair< SkColorType, bool >	supportedReadPixelsColorType (SkColorType srcColorType, const TextureInfo &srcTextureInfo, SkColorType dstColorType) const override

Additional Inherited Members
Protected Member Functions inherited from skgpu::graphite::Caps
	Caps ()

void	finishInitialization (const ContextOptions &)

Static Protected Member Functions inherited from skgpu::graphite::Caps
static uint32_t	SamplesToKey (uint32_t numSamples)

Protected Attributes inherited from skgpu::graphite::Caps
int	fMaxTextureSize = 0

int	fDefaultMSAASamples = 4

size_t	fRequiredUniformBufferAlignment = 0

size_t	fRequiredStorageBufferAlignment = 0

size_t	fRequiredTransferBufferAlignment = 0

size_t	fTextureDataRowBytesAlignment = 1

std::unique_ptr< SkSL::ShaderCaps >	fShaderCaps

bool	fClampToBorderSupport = true

bool	fProtectedSupport = false

bool	fSemaphoreSupport = false

bool	fAllowCpuSync = true

bool	fStorageBufferSupport = false

bool	fStorageBufferPreferred = false

bool	fDrawBufferCanBeMapped = true

bool	fBufferMapsAreAsync = false

bool	fMSAARenderToSingleSampledSupport = false

bool	fComputeSupport = false

bool	fSupportsAHardwareBufferImages = false

bool	fFullCompressedUploadSizeMustAlignToBlockDims = false

ResourceBindingRequirements	fResourceBindingReqs

ShaderErrorHandler *	fShaderErrorHandler = nullptr

size_t	fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4

float	fMinDistanceFieldFontSize = 18

float	fGlyphsAsPathsFontSize = 324

int	fMaxPathAtlasTextureSize = 8192

bool	fAllowMultipleAtlasTextures = true

bool	fSupportBilerpFromGlyphAtlas = false

bool	fRequireOrderedRecordings = false

Detailed Description

Definition at line 22 of file DawnCaps.h.

Constructor & Destructor Documentation

◆ DawnCaps()

skgpu::graphite::DawnCaps::DawnCaps	(	const DawnBackendContext &	backendContext,
		const ContextOptions &	options
	)

Definition at line 72 of file DawnCaps.cpp.

    : Caps() {
    this->initCaps(backendContext, options);
    this->initShaderCaps(backendContext.fDevice);
    this->initFormatTable(backendContext.fDevice);
    this->finishInitialization(options);
}

◆ ~DawnCaps()

skgpu::graphite::DawnCaps::~DawnCaps ( )

overridedefault

Member Function Documentation

◆ allowScopedErrorChecks()

bool skgpu::graphite::DawnCaps::allowScopedErrorChecks ( ) const

inline

Definition at line 28 of file DawnCaps.h.

28{ return fAllowScopedErrorChecks; }

◆ buildKeyForTexture()

void skgpu::graphite::DawnCaps::buildKeyForTexture	(	SkISize	dimensions,
		const TextureInfo &	info,
		ResourceType	type,
		Shareable	shareable,
		GraphiteResourceKey *	key
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 888 of file DawnCaps.cpp.

                                                                  {
    const DawnTextureSpec& dawnSpec = info.dawnTextureSpec();
 
    SkASSERT(!dimensions.isEmpty());
 
    SkASSERT(dawnSpec.getViewFormat() != wgpu::TextureFormat::Undefined);
    uint32_t formatKey = static_cast<uint32_t>(dawnSpec.getViewFormat());
 
    uint32_t samplesKey = SamplesToKey(info.numSamples());
    // We don't have to key the number of mip levels because it is inherit in the combination of
    // isMipped and dimensions.
    bool isMipped = info.mipmapped() == Mipmapped::kYes;
 
    // Confirm all the below parts of the key can fit in a single uint32_t. The sum of the shift
    // amounts in the asserts must be less than or equal to 32.
    SkASSERT(samplesKey                             < (1u << 3));  // sample key is first 3 bits
    SkASSERT(static_cast<uint32_t>(isMipped)        < (1u << 1));  // isMapped is 4th bit
    SkASSERT(static_cast<uint32_t>(dawnSpec.fUsage) < (1u << 28)); // usage is remaining 28 bits
 
    // We need two uint32_ts for dimensions, 1 for format, and 1 for the rest of the key;
    static int kNum32DataCnt = 2 + 1 + 1;
 
    GraphiteResourceKey::Builder builder(key, type, kNum32DataCnt, shareable);
 
    builder[0] = dimensions.width();
    builder[1] = dimensions.height();
    builder[2] = formatKey;
    builder[3] = (samplesKey                                   << 0) |
                 (static_cast<uint32_t>(isMipped)              << 3) |
                 (static_cast<uint32_t>(dawnSpec.fUsage)       << 4);
}

◆ channelMask()

uint32_t skgpu::graphite::DawnCaps::channelMask ( const TextureInfo & info ) const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 82 of file DawnCaps.cpp.

                                                            {
    return DawnFormatChannels(info.dawnTextureSpec().getViewFormat());
}

◆ getColorTypeInfo()

const Caps::ColorTypeInfo * skgpu::graphite::DawnCaps::getColorTypeInfo	(	SkColorType	colorType,
		const TextureInfo &	textureInfo
	)		const

overrideprivatevirtual

Implements skgpu::graphite::Caps.

Definition at line 344 of file DawnCaps.cpp.

                                                                                            {
    auto dawnFormat = textureInfo.dawnTextureSpec().getViewFormat();
    if (dawnFormat == wgpu::TextureFormat::Undefined) {
        SkASSERT(false);
        return nullptr;
    }
 
    const FormatInfo& info = this->getFormatInfo(dawnFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        const ColorTypeInfo& ctInfo = info.fColorTypeInfos[i];
        if (ctInfo.fColorType == colorType) {
            return &ctInfo;
        }
    }
 
    return nullptr;
}

◆ getDefaultCompressedTextureInfo()

TextureInfo skgpu::graphite::DawnCaps::getDefaultCompressedTextureInfo	(	SkTextureCompressionType	compression,
		Mipmapped	mipmapped,
		Protected
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 236 of file DawnCaps.cpp.

                                                                       {
    wgpu::TextureUsage usage = wgpu::TextureUsage::TextureBinding |
                               wgpu::TextureUsage::CopyDst |
                               wgpu::TextureUsage::CopySrc;
 
    wgpu::TextureFormat format = format_from_compression(compression);
    if (format == wgpu::TextureFormat::Undefined) {
        return {};
    }
 
    DawnTextureInfo info;
    info.fSampleCount = 1;
    info.fMipmapped = mipmapped;
    info.fFormat = format;
    info.fViewFormat = format;
    info.fUsage = usage;
 
    return info;
}

◆ getDefaultDepthStencilTextureInfo()

TextureInfo skgpu::graphite::DawnCaps::getDefaultDepthStencilTextureInfo	(	SkEnumBitMask< DepthStencilFlags >	depthStencilType,
		uint32_t	sampleCount,
		Protected
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 281 of file DawnCaps.cpp.

                     {
    DawnTextureInfo info;
    info.fSampleCount = sampleCount;
    info.fMipmapped   = Mipmapped::kNo;
    info.fFormat      = DawnDepthStencilFlagsToFormat(depthStencilType);
    info.fViewFormat = info.fFormat;
    info.fUsage       = wgpu::TextureUsage::RenderAttachment;
 
#if !defined(__EMSCRIPTEN__)
    if (fTransientAttachmentSupport) {
        info.fUsage |= wgpu::TextureUsage::TransientAttachment;
    }
#endif
 
    return info;
}

◆ getDefaultMSAATextureInfo()

TextureInfo skgpu::graphite::DawnCaps::getDefaultMSAATextureInfo	(	const TextureInfo &	singleSampledInfo,
		Discardable	discardable
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 258 of file DawnCaps.cpp.

                                                                               {
    if (fDefaultMSAASamples <= 1) {
        return {};
    }
    const DawnTextureSpec& singleSpec = singleSampledInfo.dawnTextureSpec();
 
    DawnTextureInfo info;
    info.fSampleCount = fDefaultMSAASamples;
    info.fMipmapped   = Mipmapped::kNo;
    info.fFormat      = singleSpec.fFormat;
    info.fViewFormat = singleSpec.fFormat;
    info.fUsage       = wgpu::TextureUsage::RenderAttachment;
 
#if !defined(__EMSCRIPTEN__)
    if (fTransientAttachmentSupport && discardable == Discardable::kYes) {
        info.fUsage |= wgpu::TextureUsage::TransientAttachment;
    }
#endif
 
    return info;
}

◆ getDefaultSampledTextureInfo()

TextureInfo skgpu::graphite::DawnCaps::getDefaultSampledTextureInfo	(	SkColorType	colorType,
		Mipmapped	mipmapped,
		Protected	,
		Renderable	renderable
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 182 of file DawnCaps.cpp.

                                                                                {
    wgpu::TextureUsage usage = wgpu::TextureUsage::TextureBinding |
                               wgpu::TextureUsage::CopyDst |
                               wgpu::TextureUsage::CopySrc;
    if (renderable == Renderable::kYes) {
        usage |= wgpu::TextureUsage::RenderAttachment;
    }
 
    wgpu::TextureFormat format = this->getFormatFromColorType(colorType);
    if (format == wgpu::TextureFormat::Undefined) {
        return {};
    }
 
    DawnTextureInfo info;
    info.fSampleCount = 1;
    info.fMipmapped = mipmapped;
    info.fFormat = format;
    info.fViewFormat = format;
    info.fUsage = usage;
 
    return info;
}

◆ getDefaultStorageTextureInfo()

TextureInfo skgpu::graphite::DawnCaps::getDefaultStorageTextureInfo ( SkColorType colorType ) const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 301 of file DawnCaps.cpp.

                                                                              {
    wgpu::TextureFormat format = this->getFormatFromColorType(colorType);
    if (format == wgpu::TextureFormat::Undefined) {
        SkDebugf("colorType=%d is not supported\n", static_cast<int>(colorType));
        return {};
    }
 
    const FormatInfo& formatInfo = this->getFormatInfo(format);
    if (!SkToBool(FormatInfo::kStorage_Flag & formatInfo.fFlags)) {
        return {};
    }
 
    wgpu::TextureUsage usage = wgpu::TextureUsage::StorageBinding |
                               wgpu::TextureUsage::TextureBinding |
                               wgpu::TextureUsage::CopySrc;
    DawnTextureInfo info;
    info.fSampleCount = 1;
    info.fMipmapped = Mipmapped::kNo;
    info.fFormat = format;
    info.fViewFormat = format;
    info.fUsage = usage;
 
    return info;
}

◆ getDepthAttachmentDimensions()

SkISize skgpu::graphite::DawnCaps::getDepthAttachmentDimensions	(	const TextureInfo &	textureInfo,
		const SkISize	colorAttachmentDimensions
	)		const

overridevirtual

Reimplemented from skgpu::graphite::Caps.

Definition at line 326 of file DawnCaps.cpp.

                                                                                              {
#if !defined(__EMSCRIPTEN__)
    // For multiplanar textures, texture->textureInfo() uses the format of planes instead of
    // textures (R8, R8G8, vs R8BG8Biplanar420Unorm), so we have to query texture format from
    // wgpu::Texture object, and then use it reconstruct the full dimensions.
    const auto& dawnTextureSpec = textureInfo.dawnTextureSpec();
    wgpu::TextureFormat format = dawnTextureSpec.fFormat;
    if (IsMultiplanarFormat(format) && dawnTextureSpec.fAspect == wgpu::TextureAspect::Plane1Only) {
        // Dawn requires depth attachment to match the size of Y plane (texture size).
        return SkISize::Make(colorAttachmentDimensions.width() * 2,
                             colorAttachmentDimensions.height() * 2);
    }
#endif
 
    return colorAttachmentDimensions;
}

◆ getRenderPassDescKey()

uint64_t skgpu::graphite::DawnCaps::getRenderPassDescKey ( const RenderPassDesc & renderPassDesc ) const

Definition at line 836 of file DawnCaps.cpp.

                                                                                  {
    DawnTextureInfo colorInfo, depthStencilInfo;
    renderPassDesc.fColorAttachment.fTextureInfo.getDawnTextureInfo(&colorInfo);
    renderPassDesc.fDepthStencilAttachment.fTextureInfo.getDawnTextureInfo(&depthStencilInfo);
    SkASSERT(static_cast<uint32_t>(colorInfo.getViewFormat()) <= 0xffff &&
             static_cast<uint32_t>(depthStencilInfo.getViewFormat()) <= 0xffff);
    uint32_t colorAttachmentKey =
            static_cast<uint32_t>(colorInfo.getViewFormat()) << 16 | colorInfo.fSampleCount;
    uint32_t dsAttachmentKey = static_cast<uint32_t>(depthStencilInfo.getViewFormat()) << 16 |
                               depthStencilInfo.fSampleCount;
    return (((uint64_t) colorAttachmentKey) << 32) | dsAttachmentKey;
}

◆ getTextureInfoForSampledCopy()

TextureInfo skgpu::graphite::DawnCaps::getTextureInfoForSampledCopy	(	const TextureInfo &	textureInfo,
		Mipmapped	mipmapped
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 208 of file DawnCaps.cpp.

                                                                              {
    DawnTextureInfo info;
    if (!textureInfo.getDawnTextureInfo(&info)) {
        return {};
    }
 
    info.fSampleCount = 1;
    info.fMipmapped = mipmapped;
    info.fUsage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopyDst |
                  wgpu::TextureUsage::CopySrc;
 
    return info;
}

◆ isRenderable()

bool skgpu::graphite::DawnCaps::isRenderable ( const TextureInfo & info ) const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 149 of file DawnCaps.cpp.

                                                         {
    return info.isValid() &&
           (info.dawnTextureSpec().fUsage & wgpu::TextureUsage::RenderAttachment) &&
           this->isRenderable(info.dawnTextureSpec().getViewFormat(), info.numSamples());
}

◆ isStorage()

bool skgpu::graphite::DawnCaps::isStorage ( const TextureInfo & info ) const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 155 of file DawnCaps.cpp.

                                                      {
    if (!info.isValid()) {
        return false;
    }
    if (!(info.dawnTextureSpec().fUsage & wgpu::TextureUsage::StorageBinding)) {
        return false;
    }
    const FormatInfo& formatInfo = this->getFormatInfo(info.dawnTextureSpec().getViewFormat());
    return info.numSamples() == 1 && SkToBool(FormatInfo::kStorage_Flag & formatInfo.fFlags);
}

◆ makeComputePipelineKey()

UniqueKey skgpu::graphite::DawnCaps::makeComputePipelineKey ( const ComputePipelineDesc & pipelineDesc ) const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 871 of file DawnCaps.cpp.

                                                                                        {
    UniqueKey pipelineKey;
    {
        static const skgpu::UniqueKey::Domain kComputePipelineDomain = UniqueKey::GenerateDomain();
        // The key is made up of a single uint32_t corresponding to the compute step ID.
        UniqueKey::Builder builder(&pipelineKey, kComputePipelineDomain, 1, "ComputePipeline");
        builder[0] = pipelineDesc.computeStep()->uniqueID();
 
        // TODO(b/240615224): The local work group size should factor into the key here since it is
        // specified in the shader text on Dawn/SPIR-V. This is not a problem right now since
        // ComputeSteps don't vary their workgroup size dynamically.
 
        builder.finish();
    }
    return pipelineKey;
}

◆ makeGraphicsPipelineKey()

UniqueKey skgpu::graphite::DawnCaps::makeGraphicsPipelineKey	(	const GraphicsPipelineDesc &	pipelineDesc,
		const RenderPassDesc &	renderPassDesc
	)		const

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 849 of file DawnCaps.cpp.

                                                                                        {
    UniqueKey pipelineKey;
    {
        static const skgpu::UniqueKey::Domain kGraphicsPipelineDomain = UniqueKey::GenerateDomain();
        // 5 uint32_t's (render step id, paint id, uint64 RenderPass desc, uint16 write swizzle)
        UniqueKey::Builder builder(&pipelineKey, kGraphicsPipelineDomain, 5, "GraphicsPipeline");
        // add GraphicsPipelineDesc key
        builder[0] = pipelineDesc.renderStepID();
        builder[1] = pipelineDesc.paintParamsID().asUInt();
 
        // add RenderPassDesc key
        uint64_t renderPassKey = this->getRenderPassDescKey(renderPassDesc);
        builder[2] = renderPassKey & 0xFFFFFFFF;
        builder[3] = (renderPassKey >> 32) & 0xFFFFFFFF;
        builder[4] = renderPassDesc.fWriteSwizzle.asKey();
        builder.finish();
    }
 
    return pipelineKey;
}

◆ onIsTexturable()

bool skgpu::graphite::DawnCaps::onIsTexturable ( const TextureInfo & info ) const

overrideprivatevirtual

Implements skgpu::graphite::Caps.

Definition at line 86 of file DawnCaps.cpp.

                                                           {
    if (!info.isValid()) {
        return false;
    }
 
    const auto& spec = info.dawnTextureSpec();
 
    if (!(spec.fUsage & wgpu::TextureUsage::TextureBinding)) {
        return false;
    }
 
#if !defined(__EMSCRIPTEN__)
    switch (spec.fFormat) {
        case wgpu::TextureFormat::R8BG8Biplanar420Unorm: {
            if (spec.fAspect == wgpu::TextureAspect::Plane0Only &&
                spec.getViewFormat() != wgpu::TextureFormat::R8Unorm) {
                return false;
            }
            if (spec.fAspect == wgpu::TextureAspect::Plane1Only &&
                spec.getViewFormat() != wgpu::TextureFormat::RG8Unorm) {
                return false;
            }
            break;
        }
        case wgpu::TextureFormat::R10X6BG10X6Biplanar420Unorm: {
            if (spec.fAspect == wgpu::TextureAspect::Plane0Only &&
                spec.getViewFormat() != wgpu::TextureFormat::R16Unorm) {
                return false;
            }
            if (spec.fAspect == wgpu::TextureAspect::Plane1Only &&
                spec.getViewFormat() != wgpu::TextureFormat::RG16Unorm) {
                return false;
            }
            break;
        }
        case wgpu::TextureFormat::R8BG8A8Triplanar420Unorm: {
            if (spec.fAspect == wgpu::TextureAspect::Plane0Only &&
                spec.getViewFormat() != wgpu::TextureFormat::R8Unorm) {
                return false;
            }
            if (spec.fAspect == wgpu::TextureAspect::Plane1Only &&
                spec.getViewFormat() != wgpu::TextureFormat::RG8Unorm) {
                return false;
            }
            if (spec.fAspect == wgpu::TextureAspect::Plane2Only &&
                spec.getViewFormat() != wgpu::TextureFormat::R8Unorm) {
                return false;
            }
            break;
        }
        default:
            break;
    }
#endif
 
    return this->isTexturable(info.dawnTextureSpec().getViewFormat());
}

◆ supportedReadPixelsColorType()

std::pair< SkColorType, bool > skgpu::graphite::DawnCaps::supportedReadPixelsColorType	(	SkColorType	srcColorType,
		const TextureInfo &	srcTextureInfo,
		SkColorType	dstColorType
	)		const

overrideprivatevirtual

Given a src surface's color type and its texture info as well as a color type the caller would like read into, this provides a legal color type that the caller can use for readPixels. The returned color type may differ from the passed dstColorType, in which case the caller must convert the read pixel data (see GrConvertPixels). When converting to dstColorType the swizzle in the returned struct should be applied. The caller must check the returned color type for kUnknown.

We currently don't have an SkColorType for a 3 channel RGB format. Additionally the current implementation of raster pipeline requires power of 2 channels, so it is not easy to add such an SkColorType. Thus we need to check for data that is 3 channels using the isRGBFormat return value and handle it manually

Implements skgpu::graphite::Caps.

Definition at line 380 of file DawnCaps.cpp.

                                        {
    auto dawnFormat = getFormatFromColorType(srcColorType);
    const FormatInfo& info = this->getFormatInfo(dawnFormat);
    for (int i = 0; i < info.fColorTypeInfoCount; ++i) {
        const auto& ctInfo = info.fColorTypeInfos[i];
        if (ctInfo.fColorType == srcColorType) {
            return {srcColorType, false};
        }
    }
    return {kUnknown_SkColorType, false};
}

◆ supportedWritePixelsColorType()

std::pair< SkColorType, bool > skgpu::graphite::DawnCaps::supportedWritePixelsColorType	(	SkColorType	dstColorType,
		const TextureInfo &	dstTextureInfo,
		SkColorType	srcColorType
	)		const

overrideprivatevirtual

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 writePixels.

We currently don't have an SkColorType for a 3 channel RGB format. Additionally the current implementation of raster pipeline requires power of 2 channels, so it is not easy to add such an SkColorType. Thus we need to check for data that is 3 channels using the isRGBFormat return value and handle it manually

Implements skgpu::graphite::Caps.

Definition at line 373 of file DawnCaps.cpp.

                                        {
    return {dstColorType, false};
}

◆ supportsReadPixels()

bool skgpu::graphite::DawnCaps::supportsReadPixels ( const TextureInfo & textureInfo ) const

overrideprivatevirtual

Backends may have restrictions on what types of textures support Device::readPixels(). If this returns false then the caller should implement a fallback where a temporary texture is created, the original texture is copied or drawn into it, and then pixels read from the temporary texture.

Implements skgpu::graphite::Caps.

Definition at line 368 of file DawnCaps.cpp.

                                                                      {
    const auto& spec = textureInfo.dawnTextureSpec();
    return spec.fUsage & wgpu::TextureUsage::CopySrc;
}

◆ supportsWritePixels()

bool skgpu::graphite::DawnCaps::supportsWritePixels ( const TextureInfo & textureInfo ) const

overrideprivatevirtual

Backends may have restrictions on what types of textures support Device::writePixels(). If this returns false then the caller should implement a fallback where a temporary texture is created, pixels are written to it, and then that is copied or drawn into the the surface.

Implements skgpu::graphite::Caps.

Definition at line 363 of file DawnCaps.cpp.

                                                                       {
    const auto& spec = textureInfo.dawnTextureSpec();
    return spec.fUsage & wgpu::TextureUsage::CopyDst;
}

◆ useAsyncPipelineCreation()

bool skgpu::graphite::DawnCaps::useAsyncPipelineCreation ( ) const

inline

Definition at line 27 of file DawnCaps.h.

27{ return fUseAsyncPipelineCreation; }

Member Data Documentation

◆ kFormatCnt

constexpr size_t skgpu::graphite::DawnCaps::kFormatCnt = 16

staticconstexpr

Definition at line 60 of file DawnCaps.h.

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

third_party/skia/src/gpu/graphite/dawn/DawnCaps.h
third_party/skia/src/gpu/graphite/dawn/DawnCaps.cpp

Public Member Functions

Static Public Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DawnCaps()

◆ ~DawnCaps()

Member Function Documentation

◆ allowScopedErrorChecks()

◆ buildKeyForTexture()

◆ channelMask()

◆ getColorTypeInfo()

◆ getDefaultCompressedTextureInfo()

◆ getDefaultDepthStencilTextureInfo()

◆ getDefaultMSAATextureInfo()

◆ getDefaultSampledTextureInfo()

◆ getDefaultStorageTextureInfo()

◆ getDepthAttachmentDimensions()

◆ getRenderPassDescKey()

◆ getTextureInfoForSampledCopy()

◆ isRenderable()

◆ isStorage()

◆ makeComputePipelineKey()

◆ makeGraphicsPipelineKey()

◆ onIsTexturable()

◆ supportedReadPixelsColorType()

◆ supportedWritePixelsColorType()

◆ supportsReadPixels()

◆ supportsWritePixels()

◆ useAsyncPipelineCreation()

Member Data Documentation

◆ kFormatCnt