#include <GrMockGpu.h>

Inheritance diagram for GrMockGpu:

Public Member Functions
	~GrMockGpu () override

GrThreadSafePipelineBuilder *	pipelineBuilder () override

sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder () 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

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

void	submit (GrOpsRenderPass *renderPass) override

void	checkFinishProcs () override

void	finishOutstandingGpuWork () 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 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	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >)

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)

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

void	handleDirtyContext ()

virtual void	storeVkPipelineCacheData ()

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

Private Member Functions
void	xferBarrier (GrRenderTarget *, GrXferBarrierType) 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 sizeInBytes, GrGpuBufferType, GrAccessPattern) override

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

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

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

bool	onTransferPixelsTo (GrTexture *, SkIRect, GrColorType surfaceColorType, 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	onCopySurface (GrSurface dst, const SkIRect &dstRect, GrSurface src, const SkIRect &srcRect, GrSamplerState::Filter) override

bool	onRegenerateMipMapLevels (GrTexture *) override

void	onResolveRenderTarget (GrRenderTarget *target, const SkIRect &) 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) 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

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 *, size_t) override

void	deleteBackendTexture (const GrBackendTexture &) override

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

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

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 53 of file GrMockGpu.h.

Constructor & Destructor Documentation

◆ ~GrMockGpu()

GrMockGpu::~GrMockGpu ( )

override

Definition at line 92 of file GrMockGpu.cpp.

92{}

Member Function Documentation

◆ addFinishedProc()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 181 of file GrMockGpu.h.

                                                                        {
        SkASSERT(finishedProc);
        finishedProc(finishedContext);
    }

◆ checkFinishProcs()

void GrMockGpu::checkFinishProcs ( )

inlineoverridevirtual

Implements GrGpu.

Definition at line 80 of file GrMockGpu.h.

80{}

◆ compile()

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

inlineoverrideprivatevirtual

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

Implements GrGpu.

Definition at line 243 of file GrMockGpu.h.

243{ return false; }

◆ deleteBackendTexture()

void GrMockGpu::deleteBackendTexture ( const GrBackendTexture & )

overrideprivatevirtual

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 298 of file GrMockGpu.cpp.

                                                                {
    SkASSERT(GrBackendApi::kMock == tex.backend());
 
    GrMockTextureInfo info;
    if (tex.getMockTextureInfo(&info)) {
        fOutstandingTestingOnlyTextureIDs.remove(info.id());
    }
}

◆ finishOutstandingGpuWork()

void GrMockGpu::finishOutstandingGpuWork ( )

inlineoverridevirtual

Implements GrGpu.

Definition at line 81 of file GrMockGpu.h.

81{}

◆ getPreferredStencilFormat()

GrBackendFormat GrMockGpu::getPreferredStencilFormat ( const GrBackendFormat & )

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 203 of file GrMockGpu.h.

                                                                               {
        return GrBackendFormat::MakeMock(GrColorType::kUnknown, SkTextureCompressionType::kNone,
                                         true);
    }

◆ insertSemaphore()

void GrMockGpu::insertSemaphore ( GrSemaphore * semaphore )

inlineoverridevirtual

Implements GrGpu.

Definition at line 72 of file GrMockGpu.h.

72{}

◆ Make()

std::unique_ptr< GrGpu > GrMockGpu::Make	(	const GrMockOptions *	mockOptions,
		const GrContextOptions &	contextOptions,
		GrDirectContext *	direct
	)

static

Definition at line 56 of file GrMockGpu.cpp.

                                                                {
    static const GrMockOptions kDefaultOptions = GrMockOptions();
    if (!mockOptions) {
        mockOptions = &kDefaultOptions;
    }
    return std::unique_ptr<GrGpu>(new GrMockGpu(direct, *mockOptions, contextOptions));
}

◆ makeMSAAAttachment()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 208 of file GrMockGpu.h.

                                                                               {
        return nullptr;
    }

◆ makeSemaphore()

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

inlineoverridevirtual

Implements GrGpu.

Definition at line 64 of file GrMockGpu.h.

                                                                                  {
        return nullptr;
    }

◆ makeStencilAttachment()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 245 of file GrMockGpu.cpp.

                                                                                                {
    fStats.incStencilAttachmentCreates();
    return sk_sp<GrAttachment>(new GrMockAttachment(this,
                                                    dimensions,
                                                    GrAttachment::UsageFlags::kStencilAttachment,
                                                    numStencilSamples,
                                                    /*label=*/"MockGpu_MakeStencilAttachment"));
}

◆ onClearBackendTexture()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 223 of file GrMockGpu.h.

                                                                  {
        return true;
    }

◆ onCopySurface()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 171 of file GrMockGpu.h.

                                                     {
        return true;
    }

◆ onCreateBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 255 of file GrMockGpu.cpp.

                                                                         {
    SkTextureCompressionType compression = format.asMockCompressionType();
    if (compression != SkTextureCompressionType::kNone) {
        return {}; // should go through onCreateCompressedBackendTexture
    }
 
    auto colorType = format.asMockColorType();
    if (!this->caps()->isFormatTexturable(format, GrTextureType::k2D)) {
        return GrBackendTexture();  // invalid
    }
 
    GrMockTextureInfo info(colorType, SkTextureCompressionType::kNone, NextExternalTextureID(),
                           isProtected);
 
    fOutstandingTestingOnlyTextureIDs.add(info.id());
    return GrBackendTexture(dimensions.width(), dimensions.height(), mipmapped, info);
}

◆ onCreateBuffer()

sk_sp< GrGpuBuffer > GrMockGpu::onCreateBuffer	(	size_t	sizeInBytes,
		GrGpuBufferType	type,
		GrAccessPattern	accessPattern
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 237 of file GrMockGpu.cpp.

                                                                            {
    return sk_sp<GrGpuBuffer>(
            new GrMockBuffer(this, sizeInBytes, type, accessPattern,
                             /*label=*/"MockGpu_CreateBuffer"));
}

◆ onCreateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 278 of file GrMockGpu.cpp.

                                                                                      {
    SkTextureCompressionType compression = format.asMockCompressionType();
    if (compression == SkTextureCompressionType::kNone) {
        return {}; // should go through onCreateBackendTexture
    }
 
    if (!this->caps()->isFormatTexturable(format, GrTextureType::k2D)) {
        return {};
    }
 
    GrMockTextureInfo info(GrColorType::kUnknown, compression, NextExternalTextureID(),
                           isProtected);
 
    fOutstandingTestingOnlyTextureIDs.add(info.id());
    return GrBackendTexture(dimensions.width(), dimensions.height(), mipmapped, info);
}

◆ onCreateCompressedTexture()

sk_sp< GrTexture > GrMockGpu::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 139 of file GrMockGpu.cpp.

                                                                       {
    if (fMockOptions.fFailTextureAllocations) {
        return nullptr;
    }
 
#ifdef SK_DEBUG
    // Uncompressed formats should go through onCreateTexture
    SkTextureCompressionType compression = format.asMockCompressionType();
    SkASSERT(compression != SkTextureCompressionType::kNone);
#endif
 
    GrMipmapStatus mipmapStatus = (mipmapped == skgpu::Mipmapped::kYes)
                                          ? GrMipmapStatus::kValid
                                          : GrMipmapStatus::kNotAllocated;
    GrMockTextureInfo texInfo(GrColorType::kUnknown,
                              format.asMockCompressionType(),
                              NextInternalTextureID(),
                              isProtected);
 
    return sk_sp<GrTexture>(new GrMockTexture(
            this, budgeted, dimensions, mipmapStatus, texInfo,
            /*label=*/"MockGpu_CreateCompressedTexture"));
}

◆ onCreateTexture()

sk_sp< GrTexture > GrMockGpu::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 102 of file GrMockGpu.cpp.

                                                                  {
    if (fMockOptions.fFailTextureAllocations) {
        return nullptr;
    }
 
    // Compressed formats should go through onCreateCompressedTexture
    SkASSERT(format.asMockCompressionType() == SkTextureCompressionType::kNone);
 
    GrColorType ct = format.asMockColorType();
    SkASSERT(ct != GrColorType::kUnknown);
 
    GrMipmapStatus mipmapStatus =
            mipLevelCount > 1 ? GrMipmapStatus::kDirty : GrMipmapStatus::kNotAllocated;
    GrMockTextureInfo texInfo(ct, SkTextureCompressionType::kNone, NextInternalTextureID(),
                              isProtected);
    if (renderable == GrRenderable::kYes) {
        GrMockRenderTargetInfo rtInfo(ct, NextInternalRenderTargetID(), isProtected);
        return sk_sp<GrTexture>(new GrMockTextureRenderTarget(this, budgeted, dimensions,
                                                              renderTargetSampleCnt,
                                                              mipmapStatus,
                                                              texInfo,
                                                              rtInfo,
                                                              label));
    }
    return sk_sp<GrTexture>(new GrMockTexture(
            this, budgeted, dimensions, mipmapStatus, texInfo, label));
}

◆ onGetOpsRenderPass()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 66 of file GrMockGpu.cpp.

                                                                                          {
    return new GrMockOpsRenderPass(this, rt, origin, colorInfo);
}

◆ onReadPixels()

bool GrMockGpu::onReadPixels	(	GrSurface *	,
		SkIRect	,
		GrColorType	surfaceColorType,
		GrColorType	dstColorType,
		void *	,
		size_t	rowBytes
	)

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 125 of file GrMockGpu.h.

                                                {
        return true;
    }

◆ onRegenerateMipMapLevels()

bool GrMockGpu::onRegenerateMipMapLevels ( GrTexture * )

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 177 of file GrMockGpu.h.

177{ return true; }

◆ onResolveRenderTarget()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 179 of file GrMockGpu.h.

179{}

◆ onSubmitToGpu()

bool GrMockGpu::onSubmitToGpu ( GrSyncCpu )

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 198 of file GrMockGpu.h.

198{ return true; }

◆ onTransferFromBufferToBuffer()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 144 of file GrMockGpu.h.

                                                            {
        return true;
    }

◆ onTransferPixelsFrom()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 162 of file GrMockGpu.h.

                                                      {
        return true;
    }

◆ onTransferPixelsTo()

bool GrMockGpu::onTransferPixelsTo	(	GrTexture *	,
		SkIRect	,
		GrColorType	surfaceColorType,
		GrColorType	bufferColorType,
		sk_sp< GrGpuBuffer >	,
		size_t	offset,
		size_t	rowBytes
	)

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 152 of file GrMockGpu.h.

                                                      {
        return true;
    }

◆ onUpdateCompressedBackendTexture()

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

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 234 of file GrMockGpu.h.

                                                           {
        return true;
    }

◆ onWrapBackendRenderTarget()

sk_sp< GrRenderTarget > GrMockGpu::onWrapBackendRenderTarget ( const GrBackendRenderTarget & rt )

overrideprivatevirtual

Implements GrGpu.

Definition at line 224 of file GrMockGpu.cpp.

                                                                                          {
    GrMockRenderTargetInfo info;
    SkAssertResult(rt.getMockRenderTargetInfo(&info));
 
    return sk_sp<GrRenderTarget>(
            new GrMockRenderTarget(this,
                                   GrMockRenderTarget::kWrapped,
                                   rt.dimensions(),
                                   rt.sampleCnt(),
                                   info,
                                   /*label=*/"MockGpu_WrapBackendRenderTarget"));
}

◆ onWrapBackendTexture()

sk_sp< GrTexture > GrMockGpu::onWrapBackendTexture	(	const GrBackendTexture &	tex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	wrapType,
		GrIOType	ioType
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 169 of file GrMockGpu.cpp.

                                                                  {
    GrMockTextureInfo texInfo;
    SkAssertResult(tex.getMockTextureInfo(&texInfo));
 
    SkTextureCompressionType compression = texInfo.compressionType();
    if (compression != SkTextureCompressionType::kNone) {
        return nullptr;
    }
 
    GrMipmapStatus mipmapStatus = tex.hasMipmaps() ? GrMipmapStatus::kValid
                                                   : GrMipmapStatus::kNotAllocated;
    return sk_sp<GrTexture>(new GrMockTexture(this,
                                              tex.dimensions(),
                                              mipmapStatus,
                                              texInfo,
                                              wrapType,
                                              ioType,
                                              /*label=*/"MockGpu_WrapBackendTexture"));
}

◆ onWrapCompressedBackendTexture()

sk_sp< GrTexture > GrMockGpu::onWrapCompressedBackendTexture	(	const GrBackendTexture &	tex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	wrapType
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 192 of file GrMockGpu.cpp.

                                                                                     {
    return nullptr;
}

◆ onWrapRenderableBackendTexture()

sk_sp< GrTexture > GrMockGpu::onWrapRenderableBackendTexture	(	const GrBackendTexture &	tex,
		int	sampleCnt,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 198 of file GrMockGpu.cpp.

                                                                                      {
    GrMockTextureInfo texInfo;
    SkAssertResult(tex.getMockTextureInfo(&texInfo));
    SkASSERT(texInfo.compressionType() == SkTextureCompressionType::kNone);
 
    GrMipmapStatus mipmapStatus =
            tex.hasMipmaps() ? GrMipmapStatus::kValid : GrMipmapStatus::kNotAllocated;
 
    // The client gave us the texture ID but we supply the render target ID.
    GrMockRenderTargetInfo rtInfo(texInfo.colorType(), NextInternalRenderTargetID(),
                                  texInfo.getProtected());
 
    return sk_sp<GrTexture>(
            new GrMockTextureRenderTarget(this,
                                          tex.dimensions(),
                                          sampleCnt,
                                          mipmapStatus,
                                          texInfo,
                                          rtInfo,
                                          cacheable,
                                          /*label=*/"MockGpu_WrapRenderableBackendTexture"));
}

◆ onWritePixels()

bool GrMockGpu::onWritePixels	(	GrSurface *	,
		SkIRect	,
		GrColorType	surfaceColorType,
		GrColorType	srcColorType,
		const GrMipLevel	[],
		int	mipLevelCount,
		bool	prepForTexSampling
	)

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 134 of file GrMockGpu.h.

                                                         {
        return true;
    }

◆ pipelineBuilder()

GrThreadSafePipelineBuilder * GrMockGpu::pipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 94 of file GrMockGpu.cpp.

                                                        {
    return nullptr;
}

◆ prepareTextureForCrossContextUsage()

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

inlineoverridevirtual

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 74 of file GrMockGpu.h.

                                                                                       {
        return nullptr;
    }

◆ refPipelineBuilder()

sk_sp< GrThreadSafePipelineBuilder > GrMockGpu::refPipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 98 of file GrMockGpu.cpp.

                                                                 {
    return nullptr;
}

◆ submit()

void GrMockGpu::submit ( GrOpsRenderPass * renderPass )

overridevirtual

Implements GrGpu.

Definition at line 78 of file GrMockGpu.cpp.

                                                  {
    for (int i = 0; i < static_cast<GrMockOpsRenderPass*>(renderPass)->numDraws(); ++i) {
        fStats.incNumDraws();
    }
    delete renderPass;
}

◆ waitSemaphore()

void GrMockGpu::waitSemaphore ( GrSemaphore * semaphore )

inlineoverridevirtual

Implements GrGpu.

Definition at line 73 of file GrMockGpu.h.

73{}

◆ wrapBackendSemaphore()

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

inlineoverridevirtual

Implements GrGpu.

Definition at line 67 of file GrMockGpu.h.

                                                                                  {
        return nullptr;
    }

◆ xferBarrier()

void GrMockGpu::xferBarrier	(	GrRenderTarget *	,
		GrXferBarrierType
	)

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 86 of file GrMockGpu.h.

86{}

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

third_party/skia/src/gpu/ganesh/mock/GrMockGpu.h
third_party/skia/src/gpu/ganesh/mock/GrMockGpu.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~GrMockGpu()

Member Function Documentation

◆ addFinishedProc()

◆ checkFinishProcs()

◆ compile()

◆ deleteBackendTexture()

◆ finishOutstandingGpuWork()

◆ getPreferredStencilFormat()

◆ insertSemaphore()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ onClearBackendTexture()

◆ onCopySurface()

◆ onCreateBackendTexture()

◆ onCreateBuffer()

◆ onCreateCompressedBackendTexture()

◆ onCreateCompressedTexture()

◆ onCreateTexture()

◆ onGetOpsRenderPass()

◆ onReadPixels()

◆ onRegenerateMipMapLevels()

◆ onResolveRenderTarget()

◆ onSubmitToGpu()

◆ onTransferFromBufferToBuffer()

◆ onTransferPixelsFrom()

◆ onTransferPixelsTo()

◆ onUpdateCompressedBackendTexture()

◆ onWrapBackendRenderTarget()

◆ onWrapBackendTexture()

◆ onWrapCompressedBackendTexture()

◆ onWrapRenderableBackendTexture()

◆ onWritePixels()

◆ pipelineBuilder()

◆ prepareTextureForCrossContextUsage()

◆ refPipelineBuilder()

◆ submit()

◆ waitSemaphore()

◆ wrapBackendSemaphore()

◆ xferBarrier()