#include <GrMtlGpu.h>

Inheritance diagram for GrMtlGpu:

Public Types
enum	SyncQueue { kForce_SyncQueue , kSkip_SyncQueue }

Public Types inherited from GrGpu
enum class	DisconnectType { kAbandon , kCleanup }

Public Member Functions
	~GrMtlGpu () override

void	disconnect (DisconnectType) override

GrThreadSafePipelineBuilder *	pipelineBuilder () override

sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder () override

const GrMtlCaps &	mtlCaps () const

id< MTLDevice >	device () const

GrMtlResourceProvider &	resourceProvider ()

GrStagingBufferManager *	stagingBufferManager () override

GrMtlCommandBuffer *	commandBuffer ()

void	deleteBackendTexture (const GrBackendTexture &) override

bool	compile (const GrProgramDesc &, const GrProgramInfo &) override

bool	precompileShader (const SkData &key, const SkData &data) override

void	copySurfaceAsResolve (GrSurface dst, GrSurface src)

void	copySurfaceAsBlit (GrSurface dst, GrSurface src, GrMtlAttachment dstAttachment, GrMtlAttachment srcAttachment, const SkIRect &srcRect, const SkIPoint &dstPoint)

bool	onCopySurface (GrSurface dst, const SkIRect &dstRect, GrSurface src, const SkIRect &srcRect, GrSamplerState::Filter) override

void	submit (GrOpsRenderPass *renderPass) override

std::unique_ptr< GrSemaphore >	makeSemaphore (bool isOwned) override

std::unique_ptr< GrSemaphore >	wrapBackendSemaphore (const GrBackendSemaphore &, GrSemaphoreWrapType, GrWrapOwnership) override

void	insertSemaphore (GrSemaphore *semaphore) override

void	waitSemaphore (GrSemaphore *semaphore) override

void	checkFinishProcs () override

void	finishOutstandingGpuWork () override

std::unique_ptr< GrSemaphore >	prepareTextureForCrossContextUsage (GrTexture *) override

GrMtlRenderCommandEncoder *	loadMSAAFromResolve (GrAttachment dst, GrMtlAttachment src, const SkIRect &srcRect, MTLRenderPassStencilAttachmentDescriptor *)

void	submitIndirectCommandBuffer (GrSurface surface, GrSurfaceOrigin origin, const SkIRect bounds)

GrRingBuffer *	uniformsRingBuffer () override

Public Member Functions inherited from GrGpu
	GrGpu (GrDirectContext *direct)

virtual	~GrGpu ()

GrDirectContext *	getContext ()

const GrDirectContext *	getContext () const

const GrCaps *	caps () const

sk_sp< const GrCaps >	refCaps () const

virtual bool	isDeviceLost () const

void	markContextDirty (uint32_t state=kAll_GrBackendState)

sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Budgeted budgeted, GrProtected isProtected, GrColorType textureColorType, GrColorType srcColorType, const GrMipLevel texels[], int texelLevelCount, std::string_view label)

sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Mipmapped mipmapped, skgpu::Budgeted budgeted, GrProtected isProtected, std::string_view label)

sk_sp< GrTexture >	createCompressedTexture (SkISize dimensions, const GrBackendFormat &format, skgpu::Budgeted budgeted, skgpu::Mipmapped mipmapped, GrProtected isProtected, const void *data, size_t dataSize)

sk_sp< GrTexture >	wrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType)

sk_sp< GrTexture >	wrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable)

sk_sp< GrTexture >	wrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable)

sk_sp< GrRenderTarget >	wrapBackendRenderTarget (const GrBackendRenderTarget &)

sk_sp< GrRenderTarget >	wrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &)

sk_sp< GrGpuBuffer >	createBuffer (size_t size, GrGpuBufferType intendedType, GrAccessPattern accessPattern)

void	resolveRenderTarget (GrRenderTarget *, const SkIRect &resolveRect)

bool	regenerateMipMapLevels (GrTexture *)

void	resetTextureBindings ()

bool	readPixels (GrSurface surface, SkIRect rect, GrColorType surfaceColorType, GrColorType dstColorType, void buffer, size_t rowBytes)

bool	writePixels (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType srcColorType, const GrMipLevel texels[], int mipLevelCount, bool prepForTexSampling=false)

bool	writePixels (GrSurface surface, SkIRect rect, GrColorType surfaceColorType, GrColorType srcColorType, const void buffer, size_t rowBytes, bool prepForTexSampling=false)

bool	transferFromBufferToBuffer (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size)

bool	transferPixelsTo (GrTexture *texture, SkIRect rect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset, size_t rowBytes)

bool	transferPixelsFrom (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset)

bool	copySurface (GrSurface dst, const SkIRect &dstRect, GrSurface src, const SkIRect &srcRect, GrSamplerState::Filter filter)

GrOpsRenderPass *	getOpsRenderPass (GrRenderTarget renderTarget, bool useMSAASurface, GrAttachment stencil, GrSurfaceOrigin, const SkIRect &bounds, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const skia_private::TArray< GrSurfaceProxy *, true > &sampledProxies, GrXferBarrierFlags renderPassXferBarriers)

void	executeFlushInfo (SkSpan< GrSurfaceProxy * >, SkSurfaces::BackendSurfaceAccess access, const GrFlushInfo &, const skgpu::MutableTextureState *newState)

virtual void	willExecute ()

bool	submitToGpu (GrSyncCpu sync)

bool	checkAndResetOOMed ()

virtual void	releaseUnlockedBackendObjects ()

Stats *	stats ()

void	dumpJSON (SkJSONWriter *) const

GrBackendTexture	createBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label)

bool	clearBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, std::array< float, 4 > color)

GrBackendTexture	createCompressedBackendTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, GrProtected)

bool	updateCompressedBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, const void *data, size_t length)

virtual bool	setBackendTextureState (const GrBackendTexture &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState, sk_sp< skgpu::RefCntedCallback > finishedCallback)

virtual bool	setBackendRenderTargetState (const GrBackendRenderTarget &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState, sk_sp< skgpu::RefCntedCallback > finishedCallback)

void	handleDirtyContext ()

virtual void	storeVkPipelineCacheData ()

Static Public Member Functions
static std::unique_ptr< GrGpu >	Make (const GrMtlBackendContext &, const GrContextOptions &, GrDirectContext *)

Private Member Functions
void	xferBarrier (GrRenderTarget *, GrXferBarrierType) override

void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >) override

GrBackendTexture	onCreateBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label) override

bool	onClearBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, std::array< float, 4 > color) override

GrBackendTexture	onCreateCompressedBackendTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, GrProtected) override

bool	onUpdateCompressedBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, const void *data, size_t size) override

sk_sp< GrTexture >	onCreateTexture (SkISize, const GrBackendFormat &, GrRenderable, int renderTargetSampleCnt, skgpu::Budgeted, GrProtected, int mipLevelCount, uint32_t levelClearMask, std::string_view label) override

sk_sp< GrTexture >	onCreateCompressedTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Budgeted, skgpu::Mipmapped, GrProtected, const void *data, size_t dataSize) override

sk_sp< GrTexture >	onWrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType) override

sk_sp< GrTexture >	onWrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable) override

sk_sp< GrTexture >	onWrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable) override

sk_sp< GrRenderTarget >	onWrapBackendRenderTarget (const GrBackendRenderTarget &) override

sk_sp< GrGpuBuffer >	onCreateBuffer (size_t, GrGpuBufferType, GrAccessPattern) override

bool	onReadPixels (GrSurface surface, SkIRect, GrColorType surfaceColorType, GrColorType bufferColorType, void , size_t rowBytes) override

bool	onTransferFromBufferToBuffer (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size) override

bool	onWritePixels (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType bufferColorType, const GrMipLevel[], int mipLevelCount, bool prepForTexSampling) override

bool	onTransferPixelsTo (GrTexture *, SkIRect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer >, size_t offset, size_t rowBytes) override

bool	onTransferPixelsFrom (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer >, size_t offset) override

bool	onRegenerateMipMapLevels (GrTexture *) override

void	onResolveRenderTarget (GrRenderTarget *target, const SkIRect &resolveRect) override

void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext) override

GrOpsRenderPass *	onGetOpsRenderPass (GrRenderTarget , bool useMSAASurface, GrAttachment , GrSurfaceOrigin, const SkIRect &, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const skia_private::TArray< GrSurfaceProxy *, true > &sampledProxies, GrXferBarrierFlags renderPassXferBarriers) override

bool	onSubmitToGpu (GrSyncCpu sync) override

sk_sp< GrAttachment >	makeStencilAttachment (const GrBackendFormat &, SkISize dimensions, int numStencilSamples) override

GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &) override

sk_sp< GrAttachment >	makeMSAAAttachment (SkISize dimensions, const GrBackendFormat &format, int numSamples, GrProtected isProtected, GrMemoryless isMemoryless) override

Additional Inherited Members
Protected Member Functions inherited from GrGpu
void	didWriteToSurface (GrSurface surface, GrSurfaceOrigin origin, const SkIRect bounds, uint32_t mipLevels=1) const

void	setOOMed ()

void	initCaps (sk_sp< const GrCaps > caps)

Static Protected Member Functions inherited from GrGpu
static bool	CompressedDataIsCorrect (SkISize dimensions, SkTextureCompressionType, skgpu::Mipmapped, const void *data, size_t length)

Protected Attributes inherited from GrGpu
Stats	fStats

Detailed Description

Definition at line 35 of file GrMtlGpu.h.

Member Enumeration Documentation

◆ SyncQueue

enum GrMtlGpu::SyncQueue

Enumerator
kForce_SyncQueue
kSkip_SyncQueue

Definition at line 57 of file GrMtlGpu.h.

                   {
        kForce_SyncQueue,
        kSkip_SyncQueue
    };

Constructor & Destructor Documentation

◆ ~GrMtlGpu()

GrMtlGpu::~GrMtlGpu ( )

override

Definition at line 107 of file GrMtlGpu.mm.

                    {
    if (!fDisconnected) {
        this->destroyResources();
    }
}

Member Function Documentation

◆ addFinishedProc()

void GrMtlGpu::addFinishedProc	(	GrGpuFinishedProc	finishedProc,
		GrGpuFinishedContext	finishedContext
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 271 of file GrMtlGpu.mm.

                                                                     {
    SkASSERT(finishedProc);
    this->addFinishedCallback(skgpu::RefCntedCallback::Make(finishedProc, finishedContext));
}

◆ checkFinishProcs()

void GrMtlGpu::checkFinishProcs ( )

inlineoverridevirtual

Implements GrGpu.

Definition at line 100 of file GrMtlGpu.h.

100{ this->checkForFinishedCommandBuffers(); }

◆ commandBuffer()

GrMtlCommandBuffer * GrMtlGpu::commandBuffer ( )

Definition at line 187 of file GrMtlGpu.mm.

                                            {
    if (!fCurrentCmdBuffer) {
#if GR_METAL_CAPTURE_COMMANDBUFFER
        this->testingOnly_startCapture();
#endif
        // Create a new command buffer for the next submit
        fCurrentCmdBuffer = GrMtlCommandBuffer::Make(fQueue);
    }
 
    SkASSERT(fCurrentCmdBuffer);
    return fCurrentCmdBuffer.get();
}

◆ compile()

bool GrMtlGpu::compile	(	const GrProgramDesc &	,
		const GrProgramInfo &
	)

overridevirtual

In this case we have a program descriptor and a program info but no render target.

Implements GrGpu.

Definition at line 1134 of file GrMtlGpu.mm.

                                                                                  {
 
    GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
 
    auto pipelineState = this->resourceProvider().findOrCreateCompatiblePipelineState(
                                 desc, programInfo, &stat);
    if (!pipelineState) {
        return false;
    }
 
    return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
}

◆ copySurfaceAsBlit()

void GrMtlGpu::copySurfaceAsBlit	(	GrSurface *	dst,
		GrSurface *	src,
		GrMtlAttachment *	dstAttachment,
		GrMtlAttachment *	srcAttachment,
		const SkIRect &	srcRect,
		const SkIPoint &	dstPoint
	)

Definition at line 1230 of file GrMtlGpu.mm.

                                                                                   {
#ifdef SK_DEBUG
    SkASSERT(this->mtlCaps().canCopyAsBlit(dstAttachment->mtlFormat(), dstAttachment->numSamples(),
                                           srcAttachment->mtlFormat(), dstAttachment->numSamples(),
                                           srcRect, dstPoint, dst == src));
#endif
    id<MTLTexture> GR_NORETAIN dstTex = dstAttachment->mtlTexture();
    id<MTLTexture> GR_NORETAIN srcTex = srcAttachment->mtlTexture();
 
    auto cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> GR_NORETAIN blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return;
    }
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder pushDebugGroup:@"copySurfaceAsBlit"];
#endif
    [blitCmdEncoder copyFromTexture: srcTex
                        sourceSlice: 0
                        sourceLevel: 0
                       sourceOrigin: MTLOriginMake(srcRect.x(), srcRect.y(), 0)
                         sourceSize: MTLSizeMake(srcRect.width(), srcRect.height(), 1)
                          toTexture: dstTex
                   destinationSlice: 0
                   destinationLevel: 0
                  destinationOrigin: MTLOriginMake(dstPoint.fX, dstPoint.fY, 0)];
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder popDebugGroup];
#endif
    cmdBuffer->addGrSurface(sk_ref_sp<const GrSurface>(dst));
    cmdBuffer->addGrSurface(sk_ref_sp<const GrSurface>(src));
}

◆ copySurfaceAsResolve()

void GrMtlGpu::copySurfaceAsResolve	(	GrSurface *	dst,
		GrSurface *	src
	)

Definition at line 1214 of file GrMtlGpu.mm.

                                                                  {
    // TODO: Add support for subrectangles
    GrMtlRenderTarget* srcRT = static_cast<GrMtlRenderTarget*>(src->asRenderTarget());
    GrRenderTarget* dstRT = dst->asRenderTarget();
    GrMtlAttachment* dstAttachment;
    if (dstRT) {
        GrMtlRenderTarget* mtlRT = static_cast<GrMtlRenderTarget*>(dstRT);
        dstAttachment = mtlRT->colorAttachment();
    } else {
        SkASSERT(dst->asTexture());
        dstAttachment = static_cast<GrMtlTexture*>(dst->asTexture())->attachment();
    }
 
    this->resolve(dstAttachment, srcRT->colorAttachment());
}

◆ deleteBackendTexture()

void GrMtlGpu::deleteBackendTexture ( const GrBackendTexture & )

overridevirtual

Frees a texture created by createBackendTexture(). If ownership of the backend texture has been transferred to a context using adopt semantics this should not be called.

Implements GrGpu.

Definition at line 1129 of file GrMtlGpu.mm.

                                                               {
    SkASSERT(GrBackendApi::kMetal == tex.backend());
    // Nothing to do here, will get cleaned up when the GrBackendTexture object goes away
}

◆ device()

id< MTLDevice > GrMtlGpu::device ( ) const

inline

Definition at line 49 of file GrMtlGpu.h.

49{ return fDevice; }

◆ disconnect()

void GrMtlGpu::disconnect ( DisconnectType type )

overridevirtual

Reimplemented from GrGpu.

Definition at line 113 of file GrMtlGpu.mm.

                                             {
    INHERITED::disconnect(type);
 
    if (!fDisconnected) {
        this->destroyResources();
        fDisconnected = true;
    }
}

◆ finishOutstandingGpuWork()

void GrMtlGpu::finishOutstandingGpuWork ( )

overridevirtual

Implements GrGpu.

Definition at line 262 of file GrMtlGpu.mm.

                                        {
    // wait for the last command buffer we've submitted to finish
    OutstandingCommandBuffer* back =
            (OutstandingCommandBuffer*)fOutstandingCommandBuffers.back();
    if (back) {
        (*back)->waitUntilCompleted();
    }
}

◆ getPreferredStencilFormat()

GrBackendFormat GrMtlGpu::getPreferredStencilFormat ( const GrBackendFormat & )

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 272 of file GrMtlGpu.h.

                                                                               {
        return GrBackendFormats::MakeMtl(this->mtlCaps().preferredStencilFormat());
    }

◆ insertSemaphore()

void GrMtlGpu::insertSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 1611 of file GrMtlGpu.mm.

                                                     {
    if (@available(macOS 10.14, iOS 12.0, tvOS 12.0, *)) {
        SkASSERT(semaphore);
        GrMtlSemaphore* mtlSem = static_cast<GrMtlSemaphore*>(semaphore);
 
        this->commandBuffer()->encodeSignalEvent(mtlSem->event(), mtlSem->value());
    }
}

◆ loadMSAAFromResolve()

GrMtlRenderCommandEncoder * GrMtlGpu::loadMSAAFromResolve	(	GrAttachment *	dst,
		GrMtlAttachment *	src,
		const SkIRect &	srcRect,
		MTLRenderPassStencilAttachmentDescriptor *	stencil
	)

Definition at line 1660 of file GrMtlGpu.mm.

                                                           {
    if (!dst) {
        return nil;
    }
    if (!src || src->framebufferOnly()) {
        return nil;
    }
 
    GrMtlAttachment* mtlDst = static_cast<GrMtlAttachment*>(dst);
 
    MTLPixelFormat stencilFormat = stencil.texture.pixelFormat;
    auto renderPipeline = this->resourceProvider().findOrCreateMSAALoadPipeline(mtlDst->mtlFormat(),
                                                                                dst->numSamples(),
                                                                                stencilFormat);
 
    // Set up rendercommandencoder
    auto renderPassDesc = [MTLRenderPassDescriptor new];
    auto colorAttachment = renderPassDesc.colorAttachments[0];
    colorAttachment.texture = mtlDst->mtlTexture();
    colorAttachment.loadAction = MTLLoadActionDontCare;
    colorAttachment.storeAction = MTLStoreActionMultisampleResolve;
    colorAttachment.resolveTexture = src->mtlTexture();
 
    renderPassDesc.stencilAttachment = stencil;
 
    // We know in this case that the preceding renderCommandEncoder will not be compatible.
    // Either it's using a different rendertarget, or we are reading from the resolve and
    // hence we need to let the previous resolve finish. So we create a new one without checking.
    auto renderCmdEncoder =
                this->commandBuffer()->getRenderCommandEncoder(renderPassDesc, nullptr);
    if (!renderCmdEncoder) {
        return nullptr;
    }
 
    // Bind pipeline
    renderCmdEncoder->setRenderPipelineState(renderPipeline->mtlPipelineState());
    this->commandBuffer()->addResource(sk_ref_sp(renderPipeline));
 
    // Bind src as input texture
    renderCmdEncoder->setFragmentTexture(src->mtlTexture(), 0);
    // No sampler needed
    this->commandBuffer()->addGrSurface(sk_ref_sp<GrSurface>(src));
 
    // Scissor and viewport should default to size of color attachment
 
    // Update and bind uniform data
    int w = srcRect.width();
    int h = srcRect.height();
 
    // dst rect edges in NDC (-1 to 1)
    int dw = dst->width();
    int dh = dst->height();
    float dx0 = 2.f * srcRect.fLeft / dw - 1.f;
    float dx1 = 2.f * (srcRect.fLeft + w) / dw - 1.f;
    float dy0 = 2.f * srcRect.fTop / dh - 1.f;
    float dy1 = 2.f * (srcRect.fTop + h) / dh - 1.f;
 
    struct {
        float posXform[4];
        int textureSize[2];
        int pad[2];
    } uniData = {{dx1 - dx0, dy1 - dy0, dx0, dy0}, {dw, dh}, {0, 0}};
 
    constexpr size_t uniformSize = 32;
    if (@available(macOS 10.11, iOS 8.3, tvOS 9.0, *)) {
        SkASSERT(uniformSize <= this->caps()->maxPushConstantsSize());
        renderCmdEncoder->setVertexBytes(&uniData, uniformSize, 0);
    } else {
        // upload the data
        GrRingBuffer::Slice slice = this->uniformsRingBuffer()->suballocate(uniformSize);
        GrMtlBuffer* buffer = (GrMtlBuffer*) slice.fBuffer;
        char* destPtr = static_cast<char*>(slice.fBuffer->map()) + slice.fOffset;
        memcpy(destPtr, &uniData, uniformSize);
 
        renderCmdEncoder->setVertexBuffer(buffer->mtlBuffer(), slice.fOffset, 0);
    }
 
    renderCmdEncoder->drawPrimitives(MTLPrimitiveTypeTriangleStrip, (NSUInteger)0, (NSUInteger)4);
 
    return renderCmdEncoder;
}

◆ Make()

GR_NORETAIN_BEGIN std::unique_ptr< GrGpu > GrMtlGpu::Make	(	const GrMtlBackendContext &	context,
		const GrContextOptions &	options,
		GrDirectContext *	direct
	)

static

Definition at line 56 of file GrMtlGpu.mm.

                                                               {
    if (!context.fDevice || !context.fQueue) {
        return nullptr;
    }
    if (@available(macOS 10.14, iOS 10.0, tvOS 10.0, *)) {
        // no warning needed
    } else {
        SkDebugf("*** Error ***: Skia's Metal backend no longer supports this OS version.\n");
#ifdef SK_BUILD_FOR_IOS
        SkDebugf("Minimum supported version is iOS 10.0.\n");
#else
        SkDebugf("Minimum supported version is MacOS 10.14.\n");
#endif
        return nullptr;
    }
 
    id<MTLDevice> GR_NORETAIN device = (__bridge id<MTLDevice>)(context.fDevice.get());
    id<MTLCommandQueue> GR_NORETAIN queue = (__bridge id<MTLCommandQueue>)(context.fQueue.get());
 
    return std::unique_ptr<GrGpu>(new GrMtlGpu(direct,
                                               options,
                                               device,
                                               queue));
}

◆ makeMSAAAttachment()

sk_sp< GrAttachment > GrMtlGpu::makeMSAAAttachment	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		int	numSamples,
		GrProtected	isProtected,
		GrMemoryless	isMemoryless
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 536 of file GrMtlGpu.mm.

                                                                            {
    // Metal doesn't support protected textures
    SkASSERT(isProtected == GrProtected::kNo);
    // TODO: add memoryless support
    SkASSERT(isMemoryless == GrMemoryless::kNo);
 
    MTLPixelFormat pixelFormat = (MTLPixelFormat)GrBackendFormats::AsMtlFormat(format);
    SkASSERT(pixelFormat != MTLPixelFormatInvalid);
    SkASSERT(!skgpu::MtlFormatIsCompressed(pixelFormat));
    SkASSERT(this->mtlCaps().isFormatRenderable(pixelFormat, numSamples));
 
    fStats.incMSAAAttachmentCreates();
    return GrMtlAttachment::MakeMSAA(this, dimensions, numSamples, pixelFormat);
}

◆ makeSemaphore()

std::unique_ptr< GrSemaphore > GrMtlGpu::makeSemaphore ( bool isOwned )

overridevirtual

Implements GrGpu.

Definition at line 1598 of file GrMtlGpu.mm.

                                                                       {
    SkASSERT(this->caps()->semaphoreSupport());
    return GrMtlSemaphore::Make(this);
}

◆ makeStencilAttachment()

sk_sp< GrAttachment > GrMtlGpu::makeStencilAttachment	(	const GrBackendFormat &	,
		SkISize	dimensions,
		int	numStencilSamples
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 528 of file GrMtlGpu.mm.

                                                                                               {
    MTLPixelFormat sFmt = this->mtlCaps().preferredStencilFormat();
 
    fStats.incStencilAttachmentCreates();
    return GrMtlAttachment::GrMtlAttachment::MakeStencil(this, dimensions, numStencilSamples, sFmt);
}

◆ mtlCaps()

const GrMtlCaps & GrMtlGpu::mtlCaps ( ) const

inline

Definition at line 47 of file GrMtlGpu.h.

47{ return *fMtlCaps; }

◆ onClearBackendTexture()

bool GrMtlGpu::onClearBackendTexture	(	const GrBackendTexture &	backendTexture,
		sk_sp< skgpu::RefCntedCallback >	finishedCallback,
		std::array< float, 4 >	color
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 939 of file GrMtlGpu.mm.

                                                               {
    GrMtlTextureInfo info;
    SkAssertResult(GrBackendTextures::GetMtlTextureInfo(backendTexture, &info));
 
    id<MTLTexture> GR_NORETAIN mtlTexture = GrGetMTLTexture(info.fTexture.get());
 
    const MTLPixelFormat mtlFormat = mtlTexture.pixelFormat;
 
    // Create a transfer buffer and fill with data.
    size_t bytesPerPixel = skgpu::MtlFormatBytesPerBlock(mtlFormat);
    size_t combinedBufferSize;
 
    // Reuse the same buffer for all levels. Should be ok since we made the row bytes tight.
    combinedBufferSize = bytesPerPixel*backendTexture.width()*backendTexture.height();
 
    size_t alignment = std::max(bytesPerPixel, this->mtlCaps().getMinBufferAlignment());
    GrStagingBufferManager::Slice slice = fStagingBufferManager.allocateStagingBufferSlice(
            combinedBufferSize, alignment);
    if (!slice.fBuffer) {
        return false;
    }
    char* buffer = (char*)slice.fOffsetMapPtr;
 
    auto colorType = mtl_format_to_backend_tex_clear_colortype(mtlFormat);
    if (colorType == GrColorType::kUnknown) {
        return false;
    }
    GrImageInfo ii(colorType, kUnpremul_SkAlphaType, nullptr, backendTexture.dimensions());
    auto rb = ii.minRowBytes();
    SkASSERT(rb == bytesPerPixel*backendTexture.width());
    if (!GrClearImage(ii, buffer, rb, color)) {
        return false;
    }
 
    // Transfer buffer contents to texture
    MTLOrigin origin = MTLOriginMake(0, 0, 0);
 
    GrMtlCommandBuffer* cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> GR_NORETAIN blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder pushDebugGroup:@"onClearBackendTexture"];
#endif
    GrMtlBuffer* mtlBuffer = static_cast<GrMtlBuffer*>(slice.fBuffer);
 
    SkISize levelDimensions(backendTexture.dimensions());
    int numMipLevels = mtlTexture.mipmapLevelCount;
    for (int currentMipLevel = 0; currentMipLevel < numMipLevels; currentMipLevel++) {
        size_t levelRowBytes;
        size_t levelSize;
 
        levelRowBytes = levelDimensions.width() * bytesPerPixel;
        levelSize = levelRowBytes * levelDimensions.height();
 
        // TODO: can this all be done in one go?
        [blitCmdEncoder copyFromBuffer: mtlBuffer->mtlBuffer()
                          sourceOffset: slice.fOffset
                     sourceBytesPerRow: levelRowBytes
                   sourceBytesPerImage: levelSize
                            sourceSize: MTLSizeMake(levelDimensions.width(),
                                                    levelDimensions.height(),
                                                    1)
                             toTexture: mtlTexture
                      destinationSlice: 0
                      destinationLevel: currentMipLevel
                     destinationOrigin: origin];
 
        levelDimensions = {std::max(1, levelDimensions.width() / 2),
                           std::max(1, levelDimensions.height() / 2)};
    }
#ifdef SK_BUILD_FOR_MAC
    if (this->mtlCaps().isMac()) {
        [mtlBuffer->mtlBuffer() didModifyRange: NSMakeRange(slice.fOffset, combinedBufferSize)];
    }
#endif
    [blitCmdEncoder popDebugGroup];
 
    if (finishedCallback) {
        this->addFinishedCallback(std::move(finishedCallback));
    }
 
    return true;
}

◆ onCopySurface()

bool GrMtlGpu::onCopySurface	(	GrSurface *	dst,
		const SkIRect &	dstRect,
		GrSurface *	src,
		const SkIRect &	srcRect,
		GrSamplerState::Filter
	)

overridevirtual

Implements GrGpu.

Definition at line 1265 of file GrMtlGpu.mm.

                                                   {
    SkASSERT(!src->isProtected() && !dst->isProtected());
 
    if (srcRect.size() != dstRect.size()) {
        return false;
    }
 
    GrMtlAttachment* dstAttachment;
    GrMtlAttachment* srcAttachment;
    GrRenderTarget* dstRT = dst->asRenderTarget();
    if (dstRT) {
        GrMtlRenderTarget* mtlRT = static_cast<GrMtlRenderTarget*>(dstRT);
        // This will technically return true for single sample rts that used DMSAA in which case we
        // don't have to pick the resolve attachment. But in that case the resolve and color
        // attachments will be the same anyways.
        if (this->mtlCaps().renderTargetSupportsDiscardableMSAA(mtlRT)) {
            dstAttachment = mtlRT->resolveAttachment();
        } else {
            dstAttachment = mtlRT->colorAttachment();
        }
    } else if (dst->asTexture()) {
        dstAttachment = static_cast<GrMtlTexture*>(dst->asTexture())->attachment();
    } else {
        // The surface in a GrAttachment already
        dstAttachment = static_cast<GrMtlAttachment*>(dst);
    }
    GrRenderTarget* srcRT = src->asRenderTarget();
    if (srcRT) {
        GrMtlRenderTarget* mtlRT = static_cast<GrMtlRenderTarget*>(srcRT);
        // This will technically return true for single sample rts that used DMSAA in which case we
        // don't have to pick the resolve attachment. But in that case the resolve and color
        // attachments will be the same anyways.
        if (this->mtlCaps().renderTargetSupportsDiscardableMSAA(mtlRT)) {
            srcAttachment = mtlRT->resolveAttachment();
        } else {
            srcAttachment = mtlRT->colorAttachment();
        }
    } else if (src->asTexture()) {
        SkASSERT(src->asTexture());
        srcAttachment = static_cast<GrMtlTexture*>(src->asTexture())->attachment();
    } else {
        // The surface in a GrAttachment already
        srcAttachment = static_cast<GrMtlAttachment*>(src);
    }
 
    MTLPixelFormat dstFormat = dstAttachment->mtlFormat();
    MTLPixelFormat srcFormat = srcAttachment->mtlFormat();
 
    int dstSampleCnt = dstAttachment->sampleCount();
    int srcSampleCnt = srcAttachment->sampleCount();
 
    const SkIPoint dstPoint = dstRect.topLeft();
    if (this->mtlCaps().canCopyAsResolve(dstFormat, dstSampleCnt,
                                         srcFormat, srcSampleCnt,
                                         SkToBool(srcRT), src->dimensions(),
                                         srcRect, dstPoint,
                                         dstAttachment == srcAttachment)) {
        this->copySurfaceAsResolve(dst, src);
        return true;
    }
 
    if (srcAttachment->framebufferOnly() || dstAttachment->framebufferOnly()) {
        return false;
    }
 
    if (this->mtlCaps().canCopyAsBlit(dstFormat, dstSampleCnt, srcFormat, srcSampleCnt,
                                      srcRect, dstPoint, dstAttachment == srcAttachment)) {
        this->copySurfaceAsBlit(dst, src, dstAttachment, srcAttachment, srcRect, dstPoint);
        return true;
    }
 
    return false;
}

◆ onCreateBackendTexture()

GrBackendTexture GrMtlGpu::onCreateBackendTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrRenderable	renderable,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		std::string_view	label
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 922 of file GrMtlGpu.mm.

                                                                        {
    const MTLPixelFormat mtlFormat = GrBackendFormatAsMTLPixelFormat(format);
 
    GrMtlTextureInfo info;
    if (!this->createMtlTextureForBackendSurface(mtlFormat, dimensions, 1, GrTexturable::kYes,
                                                 renderable, mipmapped, &info)) {
        return {};
    }
 
    return GrBackendTextures::MakeMtl(dimensions.width(), dimensions.height(), mipmapped, info);
}

◆ onCreateBuffer()

sk_sp< GrGpuBuffer > GrMtlGpu::onCreateBuffer	(	size_t	size,
		GrGpuBufferType	type,
		GrAccessPattern	accessPattern
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 305 of file GrMtlGpu.mm.

                                                                           {
    return GrMtlBuffer::Make(this, size, type, accessPattern);
}

◆ onCreateCompressedBackendTexture()

GrBackendTexture GrMtlGpu::onCreateCompressedBackendTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1027 of file GrMtlGpu.mm.

                                                                                     {
    const MTLPixelFormat mtlFormat = GrBackendFormatAsMTLPixelFormat(format);
 
    GrMtlTextureInfo info;
    if (!this->createMtlTextureForBackendSurface(mtlFormat, dimensions, 1, GrTexturable::kYes,
                                                 GrRenderable::kNo, mipmapped, &info)) {
        return {};
    }
 
    return GrBackendTextures::MakeMtl(dimensions.width(), dimensions.height(), mipmapped, info);
}

◆ onCreateCompressedTexture()

sk_sp< GrTexture > GrMtlGpu::onCreateCompressedTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		skgpu::Budgeted	budgeted,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		const void *	data,
		size_t	dataSize
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 599 of file GrMtlGpu.mm.

                                                                      {
    // We don't support protected textures in Metal.
    if (isProtected == GrProtected::kYes) {
        return nullptr;
    }
 
    SkASSERT(this->caps()->isFormatTexturable(format, GrTextureType::k2D));
    SkASSERT(data);
 
    if (!check_max_blit_width(dimensions.width())) {
        return nullptr;
    }
 
    MTLPixelFormat mtlPixelFormat = GrBackendFormatAsMTLPixelFormat(format);
    SkASSERT(this->caps()->isFormatCompressed(format));
 
    int numMipLevels = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
    }
 
    GrMipmapStatus mipmapStatus = (mipmapped == skgpu::Mipmapped::kYes)
                                          ? GrMipmapStatus::kValid
                                          : GrMipmapStatus::kNotAllocated;
 
    auto tex = GrMtlTexture::MakeNewTexture(this, budgeted, dimensions, mtlPixelFormat,
                                            numMipLevels, mipmapStatus,
                                            /*label=*/"MtlGpu_CreateCompressedTexture");
    if (!tex) {
        return nullptr;
    }
 
    // Upload to texture
    id<MTLTexture> GR_NORETAIN mtlTexture = tex->mtlTexture();
    SkASSERT(mtlTexture);
 
    auto compressionType = GrBackendFormatToCompressionType(format);
    SkASSERT(compressionType != SkTextureCompressionType::kNone);
 
    TArray<size_t> individualMipOffsets(numMipLevels);
    SkDEBUGCODE(size_t combinedBufferSize =)
            SkCompressedDataSize(compressionType,
                                 dimensions,
                                 &individualMipOffsets,
                                 mipmapped == skgpu::Mipmapped::kYes);
    SkASSERT(individualMipOffsets.size() == numMipLevels);
    SkASSERT(dataSize == combinedBufferSize);
 
    // offset value must be a multiple of the destination texture's pixel size in bytes
    // for compressed textures, this is the block size
    size_t alignment = SkCompressedBlockSize(compressionType);
    GrStagingBufferManager::Slice slice = fStagingBufferManager.allocateStagingBufferSlice(
            dataSize, alignment);
    if (!slice.fBuffer) {
        return nullptr;
    }
    char* bufferData = (char*)slice.fOffsetMapPtr;
    GrMtlBuffer* mtlBuffer = static_cast<GrMtlBuffer*>(slice.fBuffer);
 
    MTLOrigin origin = MTLOriginMake(0, 0, 0);
 
    auto cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> GR_NORETAIN blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return nullptr;
    }
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder pushDebugGroup:@"onCreateCompressedTexture"];
#endif
 
    // copy data into the buffer, skipping any trailing bytes
    memcpy(bufferData, data, dataSize);
 
    SkISize levelDimensions = dimensions;
    for (int currentMipLevel = 0; currentMipLevel < numMipLevels; currentMipLevel++) {
        const size_t levelRowBytes = skgpu::CompressedRowBytes(compressionType,
                                                               levelDimensions.width());
        size_t levelSize = SkCompressedDataSize(compressionType, levelDimensions, nullptr, false);
 
        // TODO: can this all be done in one go?
        [blitCmdEncoder copyFromBuffer: mtlBuffer->mtlBuffer()
                          sourceOffset: slice.fOffset + individualMipOffsets[currentMipLevel]
                     sourceBytesPerRow: levelRowBytes
                   sourceBytesPerImage: levelSize
                            sourceSize: MTLSizeMake(levelDimensions.width(),
                                                    levelDimensions.height(), 1)
                             toTexture: mtlTexture
                      destinationSlice: 0
                      destinationLevel: currentMipLevel
                     destinationOrigin: origin];
 
        levelDimensions = {std::max(1, levelDimensions.width() /2),
                           std::max(1, levelDimensions.height()/2)};
    }
#ifdef SK_BUILD_FOR_MAC
    if (this->mtlCaps().isMac()) {
        [mtlBuffer->mtlBuffer() didModifyRange: NSMakeRange(slice.fOffset, dataSize)];
    }
#endif
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder popDebugGroup];
#endif
 
    return std::move(tex);
}

◆ onCreateTexture()

sk_sp< GrTexture > GrMtlGpu::onCreateTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrRenderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		int	mipLevelCount,
		uint32_t	levelClearMask,
		std::string_view	label
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 555 of file GrMtlGpu.mm.

                                                                 {
    // We don't support protected textures in Metal.
    if (isProtected == GrProtected::kYes) {
        return nullptr;
    }
    SkASSERT(mipLevelCount > 0);
 
    MTLPixelFormat mtlPixelFormat = GrBackendFormatAsMTLPixelFormat(format);
    SkASSERT(mtlPixelFormat != MTLPixelFormatInvalid);
    SkASSERT(!this->caps()->isFormatCompressed(format));
 
    sk_sp<GrMtlTexture> tex;
    GrMipmapStatus mipmapStatus =
            mipLevelCount > 1 ? GrMipmapStatus::kDirty : GrMipmapStatus::kNotAllocated;
    if (renderable == GrRenderable::kYes) {
        tex = GrMtlTextureRenderTarget::MakeNewTextureRenderTarget(
                this, budgeted, dimensions, renderTargetSampleCnt, mtlPixelFormat, mipLevelCount,
                mipmapStatus, label);
    } else {
        tex = GrMtlTexture::MakeNewTexture(this, budgeted, dimensions, mtlPixelFormat,
                                           mipLevelCount, mipmapStatus, label);
    }
 
    if (!tex) {
        return nullptr;
    }
 
    if (levelClearMask) {
        this->clearTexture(tex.get(),
                           skgpu::MtlFormatBytesPerBlock(mtlPixelFormat),
                           levelClearMask);
    }
 
    return std::move(tex);
}

◆ onGetOpsRenderPass()

GrOpsRenderPass * GrMtlGpu::onGetOpsRenderPass	(	GrRenderTarget *	renderTarget,
		bool	useMSAASurface,
		GrAttachment *	stencil,
		GrSurfaceOrigin	origin,
		const SkIRect &	bounds,
		const GrOpsRenderPass::LoadAndStoreInfo &	colorInfo,
		const GrOpsRenderPass::StencilLoadAndStoreInfo &	stencilInfo,
		const skia_private::TArray< GrSurfaceProxy *, true > &	sampledProxies,
		GrXferBarrierFlags	renderPassXferBarriers
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 153 of file GrMtlGpu.mm.

                                                       {
    // For the given render target and requested render pass features we need to find a compatible
    // framebuffer to use.
    GrMtlRenderTarget* mtlRT = static_cast<GrMtlRenderTarget*>(renderTarget);
 
    // TODO: support DMSAA
    SkASSERT(!useMSAASurface ||
             (renderTarget->numSamples() > 1));
 
    bool withResolve = false;
 
    // Figure out if we can use a Resolve store action for this render pass. When we set up
    // the render pass we'll update the color load/store ops since we don't want to ever load
    // or store the msaa color attachment, but may need to for the resolve attachment.
    if (useMSAASurface && this->mtlCaps().renderTargetSupportsDiscardableMSAA(mtlRT)) {
        withResolve = true;
    }
 
    sk_sp<GrMtlFramebuffer> framebuffer =
            sk_ref_sp(mtlRT->getFramebuffer(withResolve, SkToBool(stencil)));
    if (!framebuffer) {
        return nullptr;
    }
 
    return new GrMtlOpsRenderPass(this, renderTarget, std::move(framebuffer), origin, colorInfo,
                                  stencilInfo);
}

◆ onReadPixels()

bool GrMtlGpu::onReadPixels	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	bufferColorType,
		void *	buffer,
		size_t	rowBytes
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1365 of file GrMtlGpu.mm.

                                             {
    SkASSERT(surface);
 
    if (surfaceColorType != dstColorType) {
        return false;
    }
 
    int bpp = GrColorTypeBytesPerPixel(dstColorType);
    size_t transBufferRowBytes = bpp*rect.width();
    size_t transBufferImageBytes = transBufferRowBytes*rect.height();
 
    GrResourceProvider* resourceProvider = this->getContext()->priv().resourceProvider();
    sk_sp<GrGpuBuffer> transferBuffer = resourceProvider->createBuffer(
            transBufferImageBytes,
            GrGpuBufferType::kXferGpuToCpu,
            kDynamic_GrAccessPattern,
            GrResourceProvider::ZeroInit::kNo);
 
    if (!transferBuffer) {
        return false;
    }
 
    GrMtlBuffer* grMtlBuffer = static_cast<GrMtlBuffer*>(transferBuffer.get());
    if (!this->readOrTransferPixels(surface,
                                    rect,
                                    dstColorType,
                                    grMtlBuffer->mtlBuffer(),
                                    0,
                                    transBufferImageBytes,
                                    transBufferRowBytes)) {
        return false;
    }
    this->submitCommandBuffer(kForce_SyncQueue);
 
    const void* mappedMemory = grMtlBuffer->mtlBuffer().contents;
 
    SkRectMemcpy(buffer,
                 rowBytes,
                 mappedMemory,
                 transBufferRowBytes,
                 transBufferRowBytes,
                 rect.height());
 
    return true;
}

◆ onRegenerateMipMapLevels()

bool GrMtlGpu::onRegenerateMipMapLevels ( GrTexture * texture )

overrideprivatevirtual

Implements GrGpu.

Definition at line 811 of file GrMtlGpu.mm.

                                                          {
    GrMtlTexture* grMtlTexture = static_cast<GrMtlTexture*>(texture);
    id<MTLTexture> GR_NORETAIN mtlTexture = grMtlTexture->mtlTexture();
 
    // Automatic mipmap generation is only supported by color-renderable formats
    if (!fMtlCaps->isFormatRenderable(mtlTexture.pixelFormat, 1) &&
        // We have pixel configs marked as textureable-only that use RGBA8 as the internal format
        MTLPixelFormatRGBA8Unorm != mtlTexture.pixelFormat) {
        return false;
    }
 
    auto cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> GR_NORETAIN blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
    [blitCmdEncoder generateMipmapsForTexture: mtlTexture];
    this->commandBuffer()->addGrSurface(sk_ref_sp<const GrSurface>(grMtlTexture->attachment()));
 
    return true;
}

◆ onResolveRenderTarget()

void GrMtlGpu::onResolveRenderTarget	(	GrRenderTarget *	target,
		const SkIRect &	resolveRect
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1629 of file GrMtlGpu.mm.

                                                                           {
    SkASSERT(target->numSamples() > 1);
    GrMtlRenderTarget* rt = static_cast<GrMtlRenderTarget*>(target);
 
    if (rt->resolveAttachment() && this->mtlCaps().renderTargetSupportsDiscardableMSAA(rt)) {
        // We would have resolved the RT during the render pass.
        return;
    }
 
    this->resolve(static_cast<GrMtlRenderTarget*>(target)->resolveAttachment(),
                  static_cast<GrMtlRenderTarget*>(target)->colorAttachment());
}

◆ onSubmitToGpu()

bool GrMtlGpu::onSubmitToGpu ( GrSyncCpu sync )

overrideprivatevirtual

Implements GrGpu.

Definition at line 292 of file GrMtlGpu.mm.

                                           {
    if (sync == GrSyncCpu::kYes) {
        return this->submitCommandBuffer(kForce_SyncQueue);
    } else {
        return this->submitCommandBuffer(kSkip_SyncQueue);
    }
}

◆ onTransferFromBufferToBuffer()

bool GrMtlGpu::onTransferFromBufferToBuffer	(	sk_sp< GrGpuBuffer >	src,
		size_t	srcOffset,
		sk_sp< GrGpuBuffer >	dst,
		size_t	dstOffset,
		size_t	size
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1416 of file GrMtlGpu.mm.

                                                         {
    id<MTLBuffer> GR_NORETAIN mtlSrc =  static_cast<GrMtlBuffer*>(src.get())->mtlBuffer();
    id<MTLBuffer> GR_NORETAIN mtlDst =  static_cast<GrMtlBuffer*>(dst.get())->mtlBuffer();
    SkASSERT(mtlSrc);
    SkASSERT(mtlDst);
 
    auto cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> GR_NORETAIN blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
 
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder pushDebugGroup:@"onTransferFromBufferToBuffer"];
#endif
    [blitCmdEncoder copyFromBuffer: mtlSrc
                      sourceOffset: srcOffset
                          toBuffer: mtlDst
                 destinationOffset: dstOffset
                              size: size];
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder popDebugGroup];
#endif
 
    cmdBuffer->addGrBuffer(std::move(src));
    cmdBuffer->addGrBuffer(std::move(dst));
 
    return true;
}

◆ onTransferPixelsFrom()

bool GrMtlGpu::onTransferPixelsFrom	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	bufferColorType,
		sk_sp< GrGpuBuffer >	transferBuffer,
		size_t	offset
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1505 of file GrMtlGpu.mm.

                                                   {
    SkASSERT(surface);
    SkASSERT(transferBuffer);
 
    if (surfaceColorType != bufferColorType) {
        return false;
    }
 
    // Metal only supports offsets that are aligned to a pixel.
    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
    if (offset % bpp) {
        return false;
    }
    if (GrBackendFormatBytesPerPixel(surface->backendFormat()) != bpp) {
        return false;
    }
 
    GrMtlBuffer* grMtlBuffer = static_cast<GrMtlBuffer*>(transferBuffer.get());
 
    size_t transBufferRowBytes = bpp*rect.width();
    size_t transBufferImageBytes = transBufferRowBytes*rect.height();
 
    return this->readOrTransferPixels(surface,
                                      rect,
                                      bufferColorType,
                                      grMtlBuffer->mtlBuffer(),
                                      offset,
                                      transBufferImageBytes,
                                      transBufferRowBytes);
}

◆ onTransferPixelsTo()

bool GrMtlGpu::onTransferPixelsTo	(	GrTexture *	texture,
		SkIRect	rect,
		GrColorType	textureColorType,
		GrColorType	bufferColorType,
		sk_sp< GrGpuBuffer >	transferBuffer,
		size_t	offset,
		size_t	rowBytes
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1450 of file GrMtlGpu.mm.

                                                   {
    SkASSERT(texture);
    SkASSERT(transferBuffer);
    if (textureColorType != bufferColorType) {
        return false;
    }
 
    GrMtlTexture* grMtlTexture = static_cast<GrMtlTexture*>(texture);
    id<MTLTexture> GR_NORETAIN mtlTexture = grMtlTexture->mtlTexture();
    SkASSERT(mtlTexture);
 
    GrMtlBuffer* grMtlBuffer = static_cast<GrMtlBuffer*>(transferBuffer.get());
    id<MTLBuffer> GR_NORETAIN mtlBuffer = grMtlBuffer->mtlBuffer();
    SkASSERT(mtlBuffer);
 
    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
    if (offset % bpp) {
        return false;
    }
    if (GrBackendFormatBytesPerPixel(texture->backendFormat()) != bpp) {
        return false;
    }
 
    MTLOrigin origin = MTLOriginMake(rect.left(), rect.top(), 0);
 
    auto cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> GR_NORETAIN blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder pushDebugGroup:@"onTransferPixelsTo"];
#endif
    [blitCmdEncoder copyFromBuffer: mtlBuffer
                      sourceOffset: offset
                 sourceBytesPerRow: rowBytes
               sourceBytesPerImage: rowBytes*rect.height()
                        sourceSize: MTLSizeMake(rect.width(), rect.height(), 1)
                         toTexture: mtlTexture
                  destinationSlice: 0
                  destinationLevel: 0
                 destinationOrigin: origin];
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder popDebugGroup];
#endif
 
    return true;
}

◆ onUpdateCompressedBackendTexture()

bool GrMtlGpu::onUpdateCompressedBackendTexture	(	const GrBackendTexture &	backendTexture,
		sk_sp< skgpu::RefCntedCallback >	finishedCallback,
		const void *	data,
		size_t	size
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1042 of file GrMtlGpu.mm.

                                                             {
    GrMtlTextureInfo info;
    SkAssertResult(GrBackendTextures::GetMtlTextureInfo(backendTexture, &info));
 
    id<MTLTexture> mtlTexture = GrGetMTLTexture(info.fTexture.get());
 
    int numMipLevels = mtlTexture.mipmapLevelCount;
    skgpu::Mipmapped mipmapped = numMipLevels > 1 ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
 
    SkTextureCompressionType compression =
            GrBackendFormatToCompressionType(backendTexture.getBackendFormat());
    SkASSERT(compression != SkTextureCompressionType::kNone);
 
    // Create a transfer buffer and fill with data.
    STArray<16, size_t> individualMipOffsets;
    size_t combinedBufferSize;
    combinedBufferSize = SkCompressedDataSize(compression,
                                              backendTexture.dimensions(),
                                              &individualMipOffsets,
                                              mipmapped == skgpu::Mipmapped::kYes);
    SkASSERT(individualMipOffsets.size() == numMipLevels);
 
    size_t alignment = std::max(SkCompressedBlockSize(compression),
                                this->mtlCaps().getMinBufferAlignment());
    GrStagingBufferManager::Slice slice =
            fStagingBufferManager.allocateStagingBufferSlice(combinedBufferSize, alignment);
    if (!slice.fBuffer) {
        return false;
    }
    char* buffer = (char*)slice.fOffsetMapPtr;
 
    memcpy(buffer, data, size);
 
    // Transfer buffer contents to texture
    MTLOrigin origin = MTLOriginMake(0, 0, 0);
 
    GrMtlCommandBuffer* cmdBuffer = this->commandBuffer();
    id<MTLBlitCommandEncoder> blitCmdEncoder = cmdBuffer->getBlitCommandEncoder();
    if (!blitCmdEncoder) {
        return false;
    }
#ifdef SK_ENABLE_MTL_DEBUG_INFO
    [blitCmdEncoder pushDebugGroup:@"onUpdateCompressedBackendTexture"];
#endif
    GrMtlBuffer* mtlBuffer = static_cast<GrMtlBuffer*>(slice.fBuffer);
 
    SkISize levelDimensions(backendTexture.dimensions());
    for (int currentMipLevel = 0; currentMipLevel < numMipLevels; currentMipLevel++) {
        size_t levelRowBytes;
        size_t levelSize;
 
        levelRowBytes = skgpu::CompressedRowBytes(compression, levelDimensions.width());
        levelSize = SkCompressedDataSize(compression, levelDimensions, nullptr, false);
 
        // TODO: can this all be done in one go?
        [blitCmdEncoder copyFromBuffer: mtlBuffer->mtlBuffer()
                          sourceOffset: slice.fOffset + individualMipOffsets[currentMipLevel]
                     sourceBytesPerRow: levelRowBytes
                   sourceBytesPerImage: levelSize
                            sourceSize: MTLSizeMake(levelDimensions.width(),
                                                    levelDimensions.height(),
                                                    1)
                             toTexture: mtlTexture
                      destinationSlice: 0
                      destinationLevel: currentMipLevel
                     destinationOrigin: origin];
 
        levelDimensions = {std::max(1, levelDimensions.width() / 2),
                           std::max(1, levelDimensions.height() / 2)};
    }
#ifdef SK_BUILD_FOR_MAC
    if (this->mtlCaps().isMac()) {
        [mtlBuffer->mtlBuffer() didModifyRange:NSMakeRange(slice.fOffset, combinedBufferSize)];
    }
#endif
    [blitCmdEncoder popDebugGroup];
 
    if (finishedCallback) {
        this->addFinishedCallback(std::move(finishedCallback));
    }
 
    return true;
}

◆ onWrapBackendRenderTarget()

sk_sp< GrRenderTarget > GrMtlGpu::onWrapBackendRenderTarget ( const GrBackendRenderTarget & backendRT )

overrideprivatevirtual

Implements GrGpu.

Definition at line 793 of file GrMtlGpu.mm.

                                                                                                {
    if (!this->caps()->isFormatRenderable(backendRT.getBackendFormat(), backendRT.sampleCnt())) {
        return nullptr;
    }
 
    id<MTLTexture> mtlTexture = get_texture_from_backend(backendRT);
    if (!mtlTexture) {
        return nullptr;
    }
 
    if (@available(macOS 10.11, iOS 9.0, tvOS 9.0, *)) {
        SkASSERT(MTLTextureUsageRenderTarget & mtlTexture.usage);
    }
 
    return GrMtlRenderTarget::MakeWrappedRenderTarget(this, backendRT.dimensions(),
                                                      backendRT.sampleCnt(), mtlTexture);
}

◆ onWrapBackendTexture()

sk_sp< GrTexture > GrMtlGpu::onWrapBackendTexture	(	const GrBackendTexture &	backendTex,
		GrWrapOwnership	,
		GrWrapCacheable	cacheable,
		GrIOType	ioType
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 729 of file GrMtlGpu.mm.

                                                                 {
    id<MTLTexture> mtlTexture = get_texture_from_backend(backendTex);
    if (!mtlTexture) {
        return nullptr;
    }
    // We don't currently support sampling from a MSAA texture in shaders.
    if (mtlTexture.sampleCount != 1) {
        return nullptr;
    }
 
    return GrMtlTexture::MakeWrappedTexture(this, backendTex.dimensions(), mtlTexture, cacheable,
                                            ioType);
}

◆ onWrapCompressedBackendTexture()

sk_sp< GrTexture > GrMtlGpu::onWrapCompressedBackendTexture	(	const GrBackendTexture &	backendTex,
		GrWrapOwnership	,
		GrWrapCacheable	cacheable
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 746 of file GrMtlGpu.mm.

                                                                                     {
    id<MTLTexture> mtlTexture = get_texture_from_backend(backendTex);
    if (!mtlTexture) {
        return nullptr;
    }
    // We don't currently support sampling from a MSAA texture in shaders.
    if (mtlTexture.sampleCount != 1) {
        return nullptr;
    }
 
    return GrMtlTexture::MakeWrappedTexture(this, backendTex.dimensions(), mtlTexture, cacheable,
                                            kRead_GrIOType);
}

◆ onWrapRenderableBackendTexture()

sk_sp< GrTexture > GrMtlGpu::onWrapRenderableBackendTexture	(	const GrBackendTexture &	backendTex,
		int	sampleCnt,
		GrWrapOwnership	,
		GrWrapCacheable	cacheable
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 762 of file GrMtlGpu.mm.

                                                                                     {
    id<MTLTexture> mtlTexture = get_texture_from_backend(backendTex);
    if (!mtlTexture) {
        return nullptr;
    }
    // We don't currently support sampling from a MSAA texture in shaders.
    if (mtlTexture.sampleCount != 1) {
        return nullptr;
    }
 
    const GrMtlCaps& caps = this->mtlCaps();
 
    MTLPixelFormat format = mtlTexture.pixelFormat;
    if (!caps.isFormatRenderable(format, sampleCnt)) {
        return nullptr;
    }
 
    if (@available(macOS 10.11, iOS 9.0, tvOS 9.0, *)) {
        SkASSERT(MTLTextureUsageRenderTarget & mtlTexture.usage);
    }
 
    sampleCnt = caps.getRenderTargetSampleCount(sampleCnt, format);
    SkASSERT(sampleCnt);
 
    return GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(
            this, backendTex.dimensions(), sampleCnt, mtlTexture, cacheable);
}

◆ onWritePixels()

bool GrMtlGpu::onWritePixels	(	GrSurface *	surface,
		SkIRect	rect,
		GrColorType	surfaceColorType,
		GrColorType	bufferColorType,
		const GrMipLevel	texels[],
		int	mipLevelCount,
		bool	prepForTexSampling
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1341 of file GrMtlGpu.mm.

                                                      {
    GrMtlTexture* mtlTexture = static_cast<GrMtlTexture*>(surface->asTexture());
    // TODO: In principle we should be able to support pure rendertargets as well, but
    // until we find a use case we'll only support texture rendertargets.
    if (!mtlTexture) {
        return false;
    }
    if (!mipLevelCount) {
        return false;
    }
#ifdef SK_DEBUG
    for (int i = 0; i < mipLevelCount; i++) {
        SkASSERT(texels[i].fPixels);
    }
#endif
    return this->uploadToTexture(mtlTexture, rect, srcColorType, texels, mipLevelCount);
}

◆ pipelineBuilder()

GrThreadSafePipelineBuilder * GrMtlGpu::pipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 122 of file GrMtlGpu.mm.

                                                       {
    return nullptr;
}

◆ precompileShader()

bool GrMtlGpu::precompileShader	(	const SkData &	key,
		const SkData &	data
	)

overridevirtual

Reimplemented from GrGpu.

Definition at line 1147 of file GrMtlGpu.mm.

                                                                     {
    return this->resourceProvider().precompileShader(key, data);
}

◆ prepareTextureForCrossContextUsage()

std::unique_ptr< GrSemaphore > GrMtlGpu::prepareTextureForCrossContextUsage ( GrTexture * )

overridevirtual

Put this texture in a safe and known state for use across multiple contexts. Depending on the backend, this may return a GrSemaphore. If so, other contexts should wait on that semaphore before using this texture.

Implements GrGpu.

Definition at line 300 of file GrMtlGpu.mm.

                                                                                  {
    this->submitToGpu(GrSyncCpu::kNo);
    return nullptr;
}

◆ refPipelineBuilder()

sk_sp< GrThreadSafePipelineBuilder > GrMtlGpu::refPipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 126 of file GrMtlGpu.mm.

                                                                {
    return nullptr;
}

◆ resourceProvider()

GrMtlResourceProvider & GrMtlGpu::resourceProvider ( )

inline

Definition at line 51 of file GrMtlGpu.h.

51{ return fResourceProvider; }

◆ stagingBufferManager()

GrStagingBufferManager * GrMtlGpu::stagingBufferManager ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 53 of file GrMtlGpu.h.

53{ return &fStagingBufferManager; }

◆ submit()

void GrMtlGpu::submit ( GrOpsRenderPass * renderPass )

overridevirtual

Implements GrGpu.

Definition at line 205 of file GrMtlGpu.mm.

                                                 {
    GrMtlOpsRenderPass* mtlRenderPass = reinterpret_cast<GrMtlOpsRenderPass*>(renderPass);
    mtlRenderPass->submit();
    delete renderPass;
}

◆ submitIndirectCommandBuffer()

void GrMtlGpu::submitIndirectCommandBuffer	(	GrSurface *	surface,
		GrSurfaceOrigin	origin,
		const SkIRect *	bounds
	)

inline

Definition at line 113 of file GrMtlGpu.h.

                                                            {
        this->didWriteToSurface(surface, origin, bounds);
    }

◆ takeOwnershipOfBuffer()

void GrMtlGpu::takeOwnershipOfBuffer ( sk_sp< GrGpuBuffer > buffer )

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 200 of file GrMtlGpu.mm.

                                                              {
    SkASSERT(buffer);
    this->commandBuffer()->addGrBuffer(std::move(buffer));
}

◆ uniformsRingBuffer()

GrRingBuffer * GrMtlGpu::uniformsRingBuffer ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 118 of file GrMtlGpu.h.

118{ return &fUniformsRingBuffer; }

◆ waitSemaphore()

void GrMtlGpu::waitSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 1620 of file GrMtlGpu.mm.

                                                   {
    if (@available(macOS 10.14, iOS 12.0, tvOS 12.0, *)) {
        SkASSERT(semaphore);
        GrMtlSemaphore* mtlSem = static_cast<GrMtlSemaphore*>(semaphore);
 
        this->commandBuffer()->encodeWaitForEvent(mtlSem->event(), mtlSem->value());
    }
}

◆ wrapBackendSemaphore()

std::unique_ptr< GrSemaphore > GrMtlGpu::wrapBackendSemaphore	(	const GrBackendSemaphore &	semaphore,
		GrSemaphoreWrapType	,
		GrWrapOwnership
	)

overridevirtual

Implements GrGpu.

Definition at line 1603 of file GrMtlGpu.mm.

                                                                               {
    SkASSERT(this->caps()->backendSemaphoreSupport());
    return GrMtlSemaphore::MakeWrapped(GrBackendSemaphores::GetMtlHandle(semaphore),
                                       GrBackendSemaphores::GetMtlValue(semaphore));
}

◆ xferBarrier()

void GrMtlGpu::xferBarrier	(	GrRenderTarget *	,
		GrXferBarrierType
	)

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 125 of file GrMtlGpu.h.

125{}

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

third_party/skia/src/gpu/ganesh/mtl/GrMtlGpu.h
third_party/skia/src/gpu/ganesh/mtl/GrMtlGpu.mm

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ SyncQueue

Constructor & Destructor Documentation

◆ ~GrMtlGpu()

Member Function Documentation

◆ addFinishedProc()

◆ checkFinishProcs()

◆ commandBuffer()

◆ compile()

◆ copySurfaceAsBlit()

◆ copySurfaceAsResolve()

◆ deleteBackendTexture()

◆ device()

◆ disconnect()

◆ finishOutstandingGpuWork()

◆ getPreferredStencilFormat()

◆ insertSemaphore()

◆ loadMSAAFromResolve()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ mtlCaps()

◆ onClearBackendTexture()

◆ onCopySurface()

◆ onCreateBackendTexture()

◆ onCreateBuffer()

◆ onCreateCompressedBackendTexture()

◆ onCreateCompressedTexture()

◆ onCreateTexture()

◆ onGetOpsRenderPass()

◆ onReadPixels()

◆ onRegenerateMipMapLevels()

◆ onResolveRenderTarget()

◆ onSubmitToGpu()

◆ onTransferFromBufferToBuffer()

◆ onTransferPixelsFrom()

◆ onTransferPixelsTo()

◆ onUpdateCompressedBackendTexture()

◆ onWrapBackendRenderTarget()

◆ onWrapBackendTexture()

◆ onWrapCompressedBackendTexture()

◆ onWrapRenderableBackendTexture()

◆ onWritePixels()

◆ pipelineBuilder()

◆ precompileShader()

◆ prepareTextureForCrossContextUsage()

◆ refPipelineBuilder()

◆ resourceProvider()

◆ stagingBufferManager()

◆ submit()

◆ submitIndirectCommandBuffer()

◆ takeOwnershipOfBuffer()

◆ uniformsRingBuffer()

◆ waitSemaphore()

◆ wrapBackendSemaphore()

◆ xferBarrier()