#include <MtlCaps.h>

Inheritance diagram for skgpu::graphite::MtlCaps:

Public Member Functions
	MtlCaps (const id< MTLDevice >, const ContextOptions &)

	~MtlCaps () override

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

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

UniqueKey	makeComputePipelineKey (const ComputePipelineDesc &) const override

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

uint64_t	getRenderPassDescKey (const RenderPassDesc &) const

bool	isMac () const

bool	isApple () const

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

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

const SkSL::ShaderCaps *	shaderCaps () const

sk_sp< SkCapabilities >	capabilities () const

virtual TextureInfo	getDefaultSampledTextureInfo (SkColorType, Mipmapped mipmapped, Protected, Renderable) const =0

virtual TextureInfo	getTextureInfoForSampledCopy (const TextureInfo &textureInfo, Mipmapped mipmapped) const =0

virtual TextureInfo	getDefaultCompressedTextureInfo (SkTextureCompressionType, Mipmapped mipmapped, Protected) const =0

virtual TextureInfo	getDefaultMSAATextureInfo (const TextureInfo &singleSampledInfo, Discardable discardable) const =0

virtual TextureInfo	getDefaultDepthStencilTextureInfo (SkEnumBitMask< DepthStencilFlags >, uint32_t sampleCount, Protected) const =0

virtual TextureInfo	getDefaultStorageTextureInfo (SkColorType) const =0

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

virtual UniqueKey	makeGraphicsPipelineKey (const GraphicsPipelineDesc &, const RenderPassDesc &) const =0

virtual UniqueKey	makeComputePipelineKey (const ComputePipelineDesc &) const =0

virtual GraphiteResourceKey	makeSamplerKey (const SamplerDesc &samplerDesc) const

virtual ImmutableSamplerInfo	getImmutableSamplerInfo (const TextureProxy *) const

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

bool	areColorTypeAndTextureInfoCompatible (SkColorType, const TextureInfo &) const

virtual uint32_t	channelMask (const TextureInfo &) const =0

bool	isTexturable (const TextureInfo &) const

virtual bool	isRenderable (const TextureInfo &) const =0

virtual bool	isStorage (const TextureInfo &) const =0

int	maxTextureSize () const

int	defaultMSAASamplesCount () const

virtual void	buildKeyForTexture (SkISize dimensions, const TextureInfo &, ResourceType, Shareable, GraphiteResourceKey *) const =0

const ResourceBindingRequirements &	resourceBindingRequirements () const

size_t	requiredUniformBufferAlignment () const

size_t	requiredStorageBufferAlignment () const

size_t	requiredTransferBufferAlignment () const

size_t	getAlignedTextureDataRowBytes (size_t rowBytes) const

virtual bool	supportsWritePixels (const TextureInfo &textureInfo) const =0

virtual bool	supportsReadPixels (const TextureInfo &textureInfo) const =0

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

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

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

bool	setBackendLabels () const

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

bool	fSetBackendLabels = false

Detailed Description

Definition at line 20 of file MtlCaps.h.

Constructor & Destructor Documentation

◆ MtlCaps()

skgpu::graphite::MtlCaps::MtlCaps	(	const id< MTLDevice >	device,
		const ContextOptions &	options
	)

Definition at line 27 of file MtlCaps.mm.

        : Caps() {
    this->initGPUFamily(device);
    this->initCaps(device);
    this->initShaderCaps();
 
    this->initFormatTable(device);
 
    // Metal-specific MtlCaps
 
    this->finishInitialization(options);
}

◆ ~MtlCaps()

skgpu::graphite::MtlCaps::~MtlCaps ( )

inlineoverride

Definition at line 23 of file MtlCaps.h.

23{}

Member Function Documentation

◆ buildKeyForTexture()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 1156 of file MtlCaps.mm.

                                                                 {
    const MtlTextureSpec& mtlSpec = info.mtlTextureSpec();
 
    SkASSERT(!dimensions.isEmpty());
 
    // A MTLPixelFormat is an NSUInteger type which is documented to be 32 bits in 32 bit
    // applications and 64 bits in 64 bit applications. So it should fit in an uint64_t, but adding
    // the assert heere to make sure.
    static_assert(sizeof(MTLPixelFormat) <= sizeof(uint64_t));
    SkASSERT(mtlSpec.fFormat != MTLPixelFormatInvalid);
    uint64_t formatKey = static_cast<uint64_t>(mtlSpec.fFormat);
 
    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;
    Protected isProtected = info.isProtected();
    bool isFBOnly = mtlSpec.fFramebufferOnly;
 
    // 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));
    SkASSERT(static_cast<uint32_t>(isMipped)    < (1u << 1));
    SkASSERT(static_cast<uint32_t>(isProtected) < (1u << 1));
    SkASSERT(mtlSpec.fUsage                     < (1u << 5));
    SkASSERT(mtlSpec.fStorageMode               < (1u << 2));
    SkASSERT(static_cast<uint32_t>(isFBOnly)    < (1u << 1));
 
    // We need two uint32_ts for dimensions, 2 for format, and 1 for the rest of the key;
    static int kNum32DataCnt = 2 + 2 + 1;
 
    GraphiteResourceKey::Builder builder(key, type, kNum32DataCnt, shareable);
 
    builder[0] = dimensions.width();
    builder[1] = dimensions.height();
    builder[2] = formatKey & 0xFFFFFFFF;
    builder[3] = (formatKey >> 32) & 0xFFFFFFFF;
    builder[4] = (samplesKey                                  << 0) |
                 (static_cast<uint32_t>(isMipped)             << 3) |
                 (static_cast<uint32_t>(isProtected)          << 4) |
                 (static_cast<uint32_t>(mtlSpec.fUsage)       << 5) |
                 (static_cast<uint32_t>(mtlSpec.fStorageMode) << 10)|
                 (static_cast<uint32_t>(isFBOnly)             << 12);
 
}

◆ channelMask()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 1024 of file MtlCaps.mm.

                                                           {
    return skgpu::MtlFormatChannels((MTLPixelFormat)info.mtlTextureSpec().fFormat);
}

◆ extractGraphicsDescs()

bool skgpu::graphite::MtlCaps::extractGraphicsDescs	(	const UniqueKey &	key,
		GraphicsPipelineDesc *	pipelineDesc,
		RenderPassDesc *	renderPassDesc,
		const RendererProvider *	rendererProvider
	)		const

overridevirtual

Reimplemented from skgpu::graphite::Caps.

Definition at line 921 of file MtlCaps.mm.

                                                                                   {
    struct UnpackedKeyData {
        // From the GraphicsPipelineDesc
        uint32_t fRenderStepID = 0;
        UniquePaintParamsID fPaintParamsID;
 
        // From the RenderPassDesc
        MtlPixelFormat fColorFormat = 0;
        uint32_t fColorSampleCount = 1;
 
        MtlPixelFormat fDSFormat = 0;
        uint32_t fDSSampleCount = 1;
 
        Swizzle fWriteSwizzle;
    } keyData;
 
    SkASSERT(key.domain() == kGraphicsPipelineDomain);
    SkASSERT(key.dataSize() == 4 * kGraphicsPipelineKeyData32Count);
 
    const uint32_t* rawKeyData = key.data();
 
    keyData.fRenderStepID = rawKeyData[0];
    keyData.fPaintParamsID = rawKeyData[1] ? UniquePaintParamsID(rawKeyData[1])
                                           : UniquePaintParamsID::InvalidID();
 
    keyData.fDSFormat = static_cast<MtlPixelFormat>((rawKeyData[2] >> 16) & 0xFFFF);
    keyData.fDSSampleCount = rawKeyData[2] & 0xFFFF;
 
    keyData.fColorFormat = static_cast<MtlPixelFormat>((rawKeyData[3] >> 16) & 0xFFFF);
    keyData.fColorSampleCount = rawKeyData[3] & 0xFFFF;
 
    keyData.fWriteSwizzle = SwizzleCtorAccessor::Make(rawKeyData[4]);
 
    // Recreate the RenderPassDesc
    SkASSERT(keyData.fColorSampleCount == keyData.fDSSampleCount);
 
    MTLPixelFormat dsFormat = (MTLPixelFormat) keyData.fDSFormat;
    SkEnumBitMask<DepthStencilFlags> dsFlags = DepthStencilFlags::kNone;
    if (MtlFormatIsDepth(dsFormat)) {
        dsFlags |= DepthStencilFlags::kDepth;
    }
    if (MtlFormatIsStencil(dsFormat)) {
        dsFlags |= DepthStencilFlags::kStencil;
    }
 
    MtlTextureInfo mtlInfo(keyData.fColorSampleCount,
                           skgpu::Mipmapped::kNo,
                           keyData.fColorFormat,
                           MTLTextureUsageShaderRead | MTLTextureUsageRenderTarget,
                           MTLStorageModePrivate,
                           /* framebufferOnly= */ false);
    TextureInfo info(mtlInfo);
 
    *renderPassDesc = RenderPassDesc::Make(this,
                                           info,
                                           LoadOp::kClear,
                                           StoreOp::kStore,
                                           dsFlags,
                                           /* clearColor= */ { .0f, .0f, .0f, .0f },
                                           /* requiresMSAA= */ keyData.fColorSampleCount > 1,
                                           keyData.fWriteSwizzle);
 
    // Recreate the GraphicsPipelineDesc
    const RenderStep* renderStep = rendererProvider->lookup(keyData.fRenderStepID);
 
    UniquePaintParamsID paintID = renderStep->performsShading() ? keyData.fPaintParamsID
                                                                : UniquePaintParamsID::InvalidID();
 
    *pipelineDesc = GraphicsPipelineDesc(renderStep, paintID);
 
    return true;
}

◆ getDefaultCompressedTextureInfo()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 761 of file MtlCaps.mm.

                                                                      {
    MTLTextureUsage usage = MTLTextureUsageShaderRead;
 
    MtlPixelFormat format = format_from_compression(compression);
    if (format == MTLPixelFormatInvalid) {
        return {};
    }
 
    MtlTextureInfo info;
    info.fSampleCount = 1;
    info.fMipmapped = mipmapped;
    info.fFormat = format;
    info.fUsage = usage;
    info.fStorageMode = MTLStorageModePrivate;
    info.fFramebufferOnly = false;
 
    return info;
}

◆ getDefaultDepthStencilTextureInfo()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 838 of file MtlCaps.mm.

                             {
    MtlTextureInfo info;
    info.fSampleCount = sampleCount;
    info.fMipmapped = Mipmapped::kNo;
    info.fFormat = this->getFormatFromDepthStencilFlags(depthStencilType);
    info.fUsage = MTLTextureUsageRenderTarget;
    info.fStorageMode = this->getDefaultMSAAStorageMode(Discardable::kYes);
    info.fFramebufferOnly = false;
 
    return info;
}

◆ getDefaultMSAATextureInfo()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 793 of file MtlCaps.mm.

                                                                              {
    if (fDefaultMSAASamples <= 1) {
        return {};
    }
    const MtlTextureSpec& singleSpec = singleSampledInfo.mtlTextureSpec();
    if (!this->isRenderable((MTLPixelFormat)singleSpec.fFormat, fDefaultMSAASamples)) {
        return {};
    }
 
    MTLTextureUsage usage = MTLTextureUsageRenderTarget;
 
    MtlTextureInfo info;
    info.fSampleCount = fDefaultMSAASamples;
    info.fMipmapped = Mipmapped::kNo;
    info.fFormat = singleSpec.fFormat;
    info.fUsage = usage;
    info.fStorageMode = this->getDefaultMSAAStorageMode(discardable);
    info.fFramebufferOnly = false;
 
    return info;
}

◆ getDefaultSampledTextureInfo()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 705 of file MtlCaps.mm.

                                                                               {
    MTLTextureUsage usage = MTLTextureUsageShaderRead;
    if (renderable == Renderable::kYes) {
        usage |= MTLTextureUsageRenderTarget;
    }
 
    MtlPixelFormat format = this->getFormatFromColorType(colorType);
    if (format == MTLPixelFormatInvalid) {
        return {};
    }
 
    MtlTextureInfo info;
    info.fSampleCount = 1;
    info.fMipmapped = mipmapped;
    info.fFormat = format;
    info.fUsage = usage;
    info.fStorageMode = MTLStorageModePrivate;
    info.fFramebufferOnly = false;
 
    return info;
}

◆ getDefaultStorageTextureInfo()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 853 of file MtlCaps.mm.

                                                                             {
    // Storage textures are currently always sampleable from a shader.
    MTLPixelFormat format = static_cast<MTLPixelFormat>(this->getFormatFromColorType(colorType));
    if (format == MTLPixelFormatInvalid) {
        return {};
    }
 
    const FormatInfo& formatInfo = this->getFormatInfo(format);
    if (!SkToBool(FormatInfo::kStorage_Flag & formatInfo.fFlags)) {
        return {};
    }
 
    MTLTextureUsage usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
    MtlTextureInfo info;
    info.fSampleCount = 1;
    info.fMipmapped = Mipmapped::kNo;
    info.fFormat = format;
    info.fUsage = usage;
    info.fStorageMode = MTLStorageModePrivate;
    info.fFramebufferOnly = false;
 
    return info;
}

◆ getRenderPassDescKey()

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

Definition at line 997 of file MtlCaps.mm.

                                                                                 {
    MtlTextureInfo colorInfo, depthStencilInfo;
    renderPassDesc.fColorAttachment.fTextureInfo.getMtlTextureInfo(&colorInfo);
    renderPassDesc.fDepthStencilAttachment.fTextureInfo.getMtlTextureInfo(&depthStencilInfo);
    SkASSERT(colorInfo.fFormat < 65535 && depthStencilInfo.fFormat < 65535);
    uint32_t colorAttachmentKey = colorInfo.fFormat << 16 | colorInfo.fSampleCount;
    uint32_t dsAttachmentKey = depthStencilInfo.fFormat << 16 | depthStencilInfo.fSampleCount;
    return (((uint64_t) colorAttachmentKey) << 32) | dsAttachmentKey;
}

◆ getTextureInfoForSampledCopy()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 730 of file MtlCaps.mm.

                                                                             {
    MtlTextureInfo info;
    if (!textureInfo.getMtlTextureInfo(&info)) {
        return {};
    }
 
    info.fSampleCount = 1;
    info.fMipmapped = mipmapped;
    info.fUsage = MTLTextureUsageShaderRead;
    info.fStorageMode = MTLStorageModePrivate;
    info.fFramebufferOnly = false;
 
    return info;
}

◆ isApple()

bool skgpu::graphite::MtlCaps::isApple ( ) const

inline

Definition at line 60 of file MtlCaps.h.

60{ return fGPUFamily == GPUFamily::kApple; }

◆ isMac()

bool skgpu::graphite::MtlCaps::isMac ( ) const

inline

Definition at line 59 of file MtlCaps.h.

59{ return fGPUFamily == GPUFamily::kMac; }

◆ isRenderable()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 1046 of file MtlCaps.mm.

                                                        {
    return info.isValid() &&
           (info.mtlTextureSpec().fUsage & MTLTextureUsageRenderTarget) &&
           this->isRenderable((MTLPixelFormat)info.mtlTextureSpec().fFormat, info.numSamples());
}

◆ isStorage()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 1056 of file MtlCaps.mm.

                                                     {
    if (!info.isValid()) {
        return false;
    }
    if (!(info.mtlTextureSpec().fUsage & MTLTextureUsageShaderWrite)) {
        return false;
    }
    if (info.mtlTextureSpec().fFramebufferOnly) {
        return false;
    }
    const FormatInfo& formatInfo =
            this->getFormatInfo((MTLPixelFormat)info.mtlTextureSpec().fFormat);
    return info.numSamples() == 1 && SkToBool(FormatInfo::kStorage_Flag & formatInfo.fFlags);
}

◆ makeComputePipelineKey()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 1007 of file MtlCaps.mm.

                                                                                       {
    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 on platforms
        // that don't support specialization constants and require the workgroup/threadgroup size to
        // be specified in the shader text (D3D12, Vulkan 1.0, and OpenGL).
 
        builder.finish();
    }
    return pipelineKey;
}

◆ makeGraphicsPipelineKey()

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

overridevirtual

Implements skgpu::graphite::Caps.

Definition at line 898 of file MtlCaps.mm.

                                                                                       {
    UniqueKey pipelineKey;
    {
        // 5 uint32_t's (render step id, paint id, uint64 renderpass desc, uint16 write swizzle key)
        UniqueKey::Builder builder(&pipelineKey, kGraphicsPipelineDomain,
                                   kGraphicsPipelineKeyData32Count, "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;
}

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

third_party/skia/src/gpu/graphite/mtl/MtlCaps.h
third_party/skia/src/gpu/graphite/mtl/MtlCaps.mm

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MtlCaps()

◆ ~MtlCaps()

Member Function Documentation

◆ buildKeyForTexture()

◆ channelMask()

◆ extractGraphicsDescs()

◆ getDefaultCompressedTextureInfo()

◆ getDefaultDepthStencilTextureInfo()

◆ getDefaultMSAATextureInfo()

◆ getDefaultSampledTextureInfo()

◆ getDefaultStorageTextureInfo()

◆ getRenderPassDescKey()

◆ getTextureInfoForSampledCopy()

◆ isApple()

◆ isMac()

◆ isRenderable()

◆ isStorage()

◆ makeComputePipelineKey()

◆ makeGraphicsPipelineKey()