#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 GrStagingBufferManager *	stagingBufferManager ()

virtual GrRingBuffer *	uniformsRingBuffer ()

virtual void	disconnect (DisconnectType)

virtual GrThreadSafePipelineBuilder *	pipelineBuilder ()=0

virtual sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder ()=0

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)

virtual void	submit (GrOpsRenderPass *)=0

virtual std::unique_ptr< GrSemaphore >	makeSemaphore (bool isOwned=true)=0

virtual std::unique_ptr< GrSemaphore >	wrapBackendSemaphore (const GrBackendSemaphore &, GrSemaphoreWrapType, GrWrapOwnership)=0

virtual void	insertSemaphore (GrSemaphore *semaphore)=0

virtual void	waitSemaphore (GrSemaphore *semaphore)=0

virtual void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)=0

virtual void	checkFinishProcs ()=0

virtual void	finishOutstandingGpuWork ()=0

virtual void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >)

bool	checkAndResetOOMed ()

virtual std::unique_ptr< GrSemaphore >	prepareTextureForCrossContextUsage (GrTexture *)=0

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)

virtual void	deleteBackendTexture (const GrBackendTexture &)=0

virtual bool	compile (const GrProgramDesc &, const GrProgramInfo &)=0

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

virtual sk_sp< GrAttachment >	makeStencilAttachment (const GrBackendFormat &colorFormat, SkISize dimensions, int numStencilSamples)=0

virtual GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &)=0

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

void	handleDirtyContext ()

virtual void	storeVkPipelineCacheData ()

virtual void	xferBarrier (GrRenderTarget *, GrXferBarrierType)=0

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

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

◆ 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();
    }
}

◆ 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));
}

◆ 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);
}

◆ mtlCaps()

const GrMtlCaps & GrMtlGpu::mtlCaps ( ) const

inline

Definition at line 47 of file GrMtlGpu.h.

47{ return *fMtlCaps; }

◆ 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;
}

◆ 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);
    }

◆ 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));
}

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

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ SyncQueue

Constructor & Destructor Documentation

◆ ~GrMtlGpu()

Member Function Documentation

◆ checkFinishProcs()

◆ commandBuffer()

◆ compile()

◆ copySurfaceAsBlit()

◆ copySurfaceAsResolve()

◆ deleteBackendTexture()

◆ device()

◆ disconnect()

◆ finishOutstandingGpuWork()

◆ insertSemaphore()

◆ loadMSAAFromResolve()

◆ Make()

◆ makeSemaphore()

◆ mtlCaps()

◆ onCopySurface()

◆ pipelineBuilder()

◆ precompileShader()

◆ prepareTextureForCrossContextUsage()

◆ refPipelineBuilder()

◆ resourceProvider()

◆ stagingBufferManager()

◆ submit()

◆ submitIndirectCommandBuffer()

◆ uniformsRingBuffer()

◆ waitSemaphore()

◆ wrapBackendSemaphore()