#include <GrD3DGpu.h>

Inheritance diagram for GrD3DGpu:

Public Member Functions
	~GrD3DGpu () override

const GrD3DCaps &	d3dCaps () const

GrD3DResourceProvider &	resourceProvider ()

GrThreadSafePipelineBuilder *	pipelineBuilder () override

sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder () override

ID3D12Device *	device () const

ID3D12CommandQueue *	queue () const

GrD3DMemoryAllocator *	memoryAllocator () const

GrD3DDirectCommandList *	currentCommandList () const

GrStagingBufferManager *	stagingBufferManager () override

void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >) override

GrRingBuffer *	uniformsRingBuffer () override

bool	protectedContext () const

void	xferBarrier (GrRenderTarget *, GrXferBarrierType) override

void	deleteBackendTexture (const GrBackendTexture &) override

bool	compile (const GrProgramDesc &, const GrProgramInfo &) 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

void	addResourceBarriers (sk_sp< GrManagedResource > resource, int numBarriers, D3D12_RESOURCE_TRANSITION_BARRIER *barriers) const

void	addBufferResourceBarriers (GrD3DBuffer buffer, int numBarriers, D3D12_RESOURCE_TRANSITION_BARRIER barriers) const

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	endRenderPass (GrRenderTarget *target, GrSurfaceOrigin origin, const SkIRect &bounds)

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 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 GrD3DBackendContext &backendContext, const GrContextOptions &, GrDirectContext *)

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 28 of file GrD3DGpu.h.

Constructor & Destructor Documentation

◆ ~GrD3DGpu()

GrD3DGpu::~GrD3DGpu ( )

override

Definition at line 109 of file GrD3DGpu.cpp.

                    {
    this->destroyResources();
}

Member Function Documentation

◆ addBufferResourceBarriers()

void GrD3DGpu::addBufferResourceBarriers	(	GrD3DBuffer *	buffer,
		int	numBarriers,
		D3D12_RESOURCE_TRANSITION_BARRIER *	barriers
	)		const

Definition at line 1729 of file GrD3DGpu.cpp.

                                                                                            {
    SkASSERT(fCurrentDirectCommandList);
    SkASSERT(buffer);
 
    fCurrentDirectCommandList->resourceBarrier(nullptr, numBarriers, barriers);
    fCurrentDirectCommandList->addGrBuffer(sk_ref_sp<const GrBuffer>(buffer));
}

◆ addResourceBarriers()

void GrD3DGpu::addResourceBarriers	(	sk_sp< GrManagedResource >	resource,
		int	numBarriers,
		D3D12_RESOURCE_TRANSITION_BARRIER *	barriers
	)		const

Definition at line 1720 of file GrD3DGpu.cpp.

                                                                                      {
    SkASSERT(fCurrentDirectCommandList);
    SkASSERT(resource);
 
    fCurrentDirectCommandList->resourceBarrier(std::move(resource), numBarriers, barriers);
}

◆ checkFinishProcs()

void GrD3DGpu::checkFinishProcs ( )

inlineoverridevirtual

Implements GrGpu.

Definition at line 117 of file GrD3DGpu.h.

117{ this->checkForFinishedCommandLists(); }

◆ compile()

bool GrD3DGpu::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 1649 of file GrD3DGpu.cpp.

                                                                 {
    return false;
}

◆ currentCommandList()

GrD3DDirectCommandList * GrD3DGpu::currentCommandList ( ) const

inline

Definition at line 48 of file GrD3DGpu.h.

48{ return fCurrentDirectCommandList.get(); }

◆ d3dCaps()

const GrD3DCaps & GrD3DGpu::d3dCaps ( ) const

inline

Definition at line 36 of file GrD3DGpu.h.

36{ return static_cast<const GrD3DCaps&>(*this->caps()); }

GrD3DCaps

Definition: GrD3DCaps.h:23

GrGpu::caps

const GrCaps * caps() const

Definition: GrGpu.h:73

◆ deleteBackendTexture()

void GrD3DGpu::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 1644 of file GrD3DGpu.cpp.

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

◆ device()

ID3D12Device * GrD3DGpu::device ( ) const

inline

Definition at line 43 of file GrD3DGpu.h.

43{ return fDevice.get(); }

gr_cp::get

T * get() const

Definition: GrD3DTypes.h:108

◆ endRenderPass()

void GrD3DGpu::endRenderPass	(	GrRenderTarget *	target,
		GrSurfaceOrigin	origin,
		const SkIRect &	bounds
	)

Definition at line 240 of file GrD3DGpu.cpp.

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

◆ finishOutstandingGpuWork()

void GrD3DGpu::finishOutstandingGpuWork ( )

overridevirtual

Implements GrGpu.

Definition at line 1800 of file GrD3DGpu.cpp.

                                        {
    this->waitForQueueCompletion();
}

◆ getPreferredStencilFormat()

GrBackendFormat GrD3DGpu::getPreferredStencilFormat ( const GrBackendFormat & )

inlineoverridevirtual

Implements GrGpu.

Definition at line 83 of file GrD3DGpu.h.

                                                                               {
        return GrBackendFormat::MakeDxgi(this->d3dCaps().preferredStencilFormat());
    }

◆ insertSemaphore()

void GrD3DGpu::insertSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 1786 of file GrD3DGpu.cpp.

                                                     {
    SkASSERT(semaphore);
    GrD3DSemaphore* d3dSem = static_cast<GrD3DSemaphore*>(semaphore);
    // TODO: Do we need to track the lifetime of this? How do we know it's done?
    fQueue->Signal(d3dSem->fence(), d3dSem->value());
}

◆ Make()

std::unique_ptr< GrGpu > GrD3DGpu::Make	(	const GrD3DBackendContext &	backendContext,
		const GrContextOptions &	contextOptions,
		GrDirectContext *	direct
	)

static

Definition at line 50 of file GrD3DGpu.cpp.

                                                               {
    sk_sp<GrD3DMemoryAllocator> memoryAllocator = backendContext.fMemoryAllocator;
    if (!memoryAllocator) {
        // We were not given a memory allocator at creation
        memoryAllocator = GrD3DAMDMemoryAllocator::Make(
                backendContext.fAdapter.get(), backendContext.fDevice.get());
    }
    if (!memoryAllocator) {
        SkDEBUGFAIL("No supplied Direct3D memory allocator and unable to create one internally.");
        return nullptr;
    }
 
    return std::unique_ptr<GrGpu>(new GrD3DGpu(direct,
                                               contextOptions,
                                               backendContext,
                                               memoryAllocator));
}

◆ makeMSAAAttachment()

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

inlineoverridevirtual

Implements GrGpu.

Definition at line 87 of file GrD3DGpu.h.

                                                                               {
        return nullptr;
    }

◆ makeSemaphore()

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

overridevirtual

Implements GrGpu.

Definition at line 1772 of file GrD3DGpu.cpp.

                                                                     {
    return GrD3DSemaphore::Make(this);
}

◆ makeStencilAttachment()

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

overridevirtual

Implements GrGpu.

Definition at line 1324 of file GrD3DGpu.cpp.

                                                                                               {
    DXGI_FORMAT sFmt = this->d3dCaps().preferredStencilFormat();
 
    fStats.incStencilAttachmentCreates();
    return GrD3DAttachment::MakeStencil(this, dimensions, numStencilSamples, sFmt);
}

◆ memoryAllocator()

GrD3DMemoryAllocator * GrD3DGpu::memoryAllocator ( ) const

inline

Definition at line 46 of file GrD3DGpu.h.

46{ return fMemoryAllocator.get(); }

sk_sp::get

T * get() const

Definition: SkRefCnt.h:303

◆ pipelineBuilder()

GrThreadSafePipelineBuilder * GrD3DGpu::pipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 41 of file GrD3DGpu.cpp.

                                                       {
    return nullptr;
}

◆ prepareTextureForCrossContextUsage()

std::unique_ptr< GrSemaphore > GrD3DGpu::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 109 of file GrD3DGpu.h.

                                                                                       {
        return nullptr;
    }

◆ protectedContext()

bool GrD3DGpu::protectedContext ( ) const

inline

Definition at line 55 of file GrD3DGpu.h.

55{ return false; }

◆ queue()

ID3D12CommandQueue * GrD3DGpu::queue ( ) const

inline

Definition at line 44 of file GrD3DGpu.h.

44{ return fQueue.get(); }

◆ refPipelineBuilder()

sk_sp< GrThreadSafePipelineBuilder > GrD3DGpu::refPipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 45 of file GrD3DGpu.cpp.

                                                                {
    return nullptr;
}

◆ resourceProvider()

GrD3DResourceProvider & GrD3DGpu::resourceProvider ( )

inline

Definition at line 38 of file GrD3DGpu.h.

38{ return fResourceProvider; }

◆ stagingBufferManager()

GrStagingBufferManager * GrD3DGpu::stagingBufferManager ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 50 of file GrD3DGpu.h.

50{ return &fStagingBufferManager; }

◆ submit()

void GrD3DGpu::submit ( GrOpsRenderPass * renderPass )

overridevirtual

Implements GrGpu.

Definition at line 233 of file GrD3DGpu.cpp.

                                                 {
    SkASSERT(fCachedOpsRenderPass.get() == renderPass);
 
    fCachedOpsRenderPass->submit();
    fCachedOpsRenderPass.reset();
}

◆ takeOwnershipOfBuffer()

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

overridevirtual

Reimplemented from GrGpu.

Definition at line 1760 of file GrD3DGpu.cpp.

                                                              {
    fCurrentDirectCommandList->addGrBuffer(std::move(buffer));
}

◆ uniformsRingBuffer()

GrRingBuffer * GrD3DGpu::uniformsRingBuffer ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 53 of file GrD3DGpu.h.

53{ return &fConstantsRingBuffer; }

◆ waitSemaphore()

void GrD3DGpu::waitSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 1793 of file GrD3DGpu.cpp.

                                                   {
    SkASSERT(semaphore);
    GrD3DSemaphore* d3dSem = static_cast<GrD3DSemaphore*>(semaphore);
    // TODO: Do we need to track the lifetime of this?
    fQueue->Wait(d3dSem->fence(), d3dSem->value());
}

◆ wrapBackendSemaphore()

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

overridevirtual

Implements GrGpu.

Definition at line 1775 of file GrD3DGpu.cpp.

                                                                               {
    SkASSERT(this->caps()->backendSemaphoreSupport());
    GrD3DFenceInfo fenceInfo;
    if (!semaphore.getD3DFenceInfo(&fenceInfo)) {
        return nullptr;
    }
    return GrD3DSemaphore::MakeWrapped(fenceInfo);
}

◆ xferBarrier()

void GrD3DGpu::xferBarrier	(	GrRenderTarget *	,
		GrXferBarrierType
	)

inlineoverridevirtual

Implements GrGpu.

Definition at line 57 of file GrD3DGpu.h.

57{}

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

third_party/skia/src/gpu/ganesh/d3d/GrD3DGpu.h
third_party/skia/src/gpu/ganesh/d3d/GrD3DGpu.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~GrD3DGpu()

Member Function Documentation

◆ addBufferResourceBarriers()

◆ addResourceBarriers()

◆ checkFinishProcs()

◆ compile()

◆ currentCommandList()

◆ d3dCaps()

◆ deleteBackendTexture()

◆ device()

◆ endRenderPass()

◆ finishOutstandingGpuWork()

◆ getPreferredStencilFormat()

◆ insertSemaphore()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ memoryAllocator()

◆ pipelineBuilder()

◆ prepareTextureForCrossContextUsage()

◆ protectedContext()

◆ queue()

◆ refPipelineBuilder()

◆ resourceProvider()

◆ stagingBufferManager()

◆ submit()

◆ takeOwnershipOfBuffer()

◆ uniformsRingBuffer()

◆ waitSemaphore()

◆ wrapBackendSemaphore()

◆ xferBarrier()