GrD3DGpu Class Reference

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

Private Member Functions
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
void	prepareSurfacesForBackendAccessAndStateUpdates (SkSpan< GrSurfaceProxy * > proxies, SkSurfaces::BackendSurfaceAccess access, const skgpu::MutableTextureState *newState) override
bool	onSubmitToGpu (GrSyncCpu sync) 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

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

addFinishedProc()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 245 of file GrD3DGpu.cpp.

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

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.

{ 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.

{ return fCurrentDirectCommandList.get(); }

d3dCaps()

const GrD3DCaps & GrD3DGpu::d3dCaps ( ) const

inline

Definition at line 36 of file GrD3DGpu.h.

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

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.

{ return fDevice.get(); }

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.

{ return fMemoryAllocator.get(); }

onClearBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1452 of file GrD3DGpu.cpp.

                                                               {
    GrD3DTextureResourceInfo info;
    SkAssertResult(backendTexture.getD3DTextureResourceInfo(&info));
    SkASSERT(!GrDxgiFormatIsCompressed(info.fFormat));
 
    sk_sp<GrD3DResourceState> state = backendTexture.getGrD3DResourceState();
    SkASSERT(state);
    sk_sp<GrD3DTexture> texture =
            GrD3DTexture::MakeWrappedTexture(this, backendTexture.dimensions(),
                                             GrWrapCacheable::kNo,
                                             kRW_GrIOType, info, std::move(state));
    if (!texture) {
        return false;
    }
 
    GrD3DDirectCommandList* cmdList = this->currentCommandList();
    if (!cmdList) {
        return false;
    }
 
    texture->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
 
    ID3D12Resource* d3dResource = texture->d3dResource();
    SkASSERT(d3dResource);
    D3D12_RESOURCE_DESC desc = d3dResource->GetDesc();
    unsigned int mipLevelCount = 1;
    if (backendTexture.fMipmapped == skgpu::Mipmapped::kYes) {
        mipLevelCount = SkMipmap::ComputeLevelCount(backendTexture.dimensions()) + 1;
    }
    SkASSERT(mipLevelCount == info.fLevelCount);
    AutoSTMalloc<15, D3D12_PLACED_SUBRESOURCE_FOOTPRINT> placedFootprints(mipLevelCount);
    UINT numRows;
    UINT64 rowSizeInBytes;
    UINT64 combinedBufferSize;
    // We reuse the same top-level buffer area for all levels, hence passing 1 for level count.
    fDevice->GetCopyableFootprints(&desc,
                                   /* first resource  */ 0,
                                   /* mip level count */ 1,
                                   /* base offset     */ 0,
                                   placedFootprints.get(),
                                   &numRows,
                                   &rowSizeInBytes,
                                   &combinedBufferSize);
    SkASSERT(combinedBufferSize);
 
    GrStagingBufferManager::Slice slice = fStagingBufferManager.allocateStagingBufferSlice(
            combinedBufferSize, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
    if (!slice.fBuffer) {
        return false;
    }
 
    char* bufferData = (char*)slice.fOffsetMapPtr;
    SkASSERT(bufferData);
    if (!copy_color_data(this->d3dCaps(),
                         bufferData,
                         info.fFormat,
                         backendTexture.dimensions(),
                         placedFootprints,
                         color)) {
        return false;
    }
    // Update the offsets in the footprint to be relative to the slice's offset
    placedFootprints[0].Offset += slice.fOffset;
    // Since we're sharing data for all the levels, set all the upper level footprints to the base.
    UINT w = placedFootprints[0].Footprint.Width;
    UINT h = placedFootprints[0].Footprint.Height;
    for (unsigned int i = 1; i < mipLevelCount; ++i) {
        w = std::max(1U, w/2);
        h = std::max(1U, h/2);
        placedFootprints[i].Offset = placedFootprints[0].Offset;
        placedFootprints[i].Footprint.Format   = placedFootprints[0].Footprint.Format;
        placedFootprints[i].Footprint.Width    = w;
        placedFootprints[i].Footprint.Height   = h;
        placedFootprints[i].Footprint.Depth    = 1;
        placedFootprints[i].Footprint.RowPitch = placedFootprints[0].Footprint.RowPitch;
    }
 
    ID3D12Resource* d3dBuffer = static_cast<GrD3DBuffer*>(slice.fBuffer)->d3dResource();
    cmdList->copyBufferToTexture(d3dBuffer,
                                 texture.get(),
                                 mipLevelCount,
                                 placedFootprints.get(),
                                 /*left*/ 0,
                                 /*top */ 0);
 
    if (finishedCallback) {
        this->addFinishedCallback(std::move(finishedCallback));
    }
 
    return true;
}

onCopySurface()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 442 of file GrD3DGpu.cpp.

                                                   {
    if (srcRect.size() != dstRect.size()) {
        return false;
    }
    if (src->isProtected() && !dst->isProtected()) {
        SkDebugf("Can't copy from protected memory to non-protected");
        return false;
    }
 
    int dstSampleCnt = get_surface_sample_cnt(dst);
    int srcSampleCnt = get_surface_sample_cnt(src);
 
    GrD3DTextureResource* dstTexResource;
    GrD3DTextureResource* srcTexResource;
    GrRenderTarget* dstRT = dst->asRenderTarget();
    if (dstRT) {
        GrD3DRenderTarget* d3dRT = static_cast<GrD3DRenderTarget*>(dstRT);
        dstTexResource = d3dRT->numSamples() > 1 ? d3dRT->msaaTextureResource() : d3dRT;
    } else {
        SkASSERT(dst->asTexture());
        dstTexResource = static_cast<GrD3DTexture*>(dst->asTexture());
    }
    GrRenderTarget* srcRT = src->asRenderTarget();
    if (srcRT) {
        GrD3DRenderTarget* d3dRT = static_cast<GrD3DRenderTarget*>(srcRT);
        srcTexResource = d3dRT->numSamples() > 1 ? d3dRT->msaaTextureResource() : d3dRT;
    } else {
        SkASSERT(src->asTexture());
        srcTexResource = static_cast<GrD3DTexture*>(src->asTexture());
    }
 
    DXGI_FORMAT dstFormat = dstTexResource->dxgiFormat();
    DXGI_FORMAT srcFormat = srcTexResource->dxgiFormat();
 
    const SkIPoint dstPoint = dstRect.topLeft();
    if (this->d3dCaps().canCopyAsResolve(dstFormat, dstSampleCnt, srcFormat, srcSampleCnt)) {
        this->copySurfaceAsResolve(dst, src, srcRect, dstPoint);
        return true;
    }
 
    if (this->d3dCaps().canCopyTexture(dstFormat, dstSampleCnt, srcFormat, srcSampleCnt)) {
        this->copySurfaceAsCopyTexture(dst, src, dstTexResource, srcTexResource, srcRect, dstPoint);
        return true;
    }
 
    return false;
}

onCreateBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1402 of file GrD3DGpu.cpp.

                                                                        {
    const GrD3DCaps& caps = this->d3dCaps();
 
    if (this->protectedContext() != (isProtected == GrProtected::kYes)) {
        return {};
    }
 
    DXGI_FORMAT dxgiFormat;
    if (!format.asDxgiFormat(&dxgiFormat)) {
        return {};
    }
 
    // TODO: move the texturability check up to GrGpu::createBackendTexture and just assert here
    if (!caps.isFormatTexturable(dxgiFormat)) {
        return {};
    }
 
    GrD3DTextureResourceInfo info;
    if (!this->createTextureResourceForBackendSurface(dxgiFormat, dimensions, GrTexturable::kYes,
                                                      renderable, mipmapped, 1, &info,
                                                      isProtected)) {
        return {};
    }
 
    return GrBackendTexture(dimensions.width(), dimensions.height(), info);
}

onCreateBuffer()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1318 of file GrD3DGpu.cpp.

                                                                           {
    return GrD3DBuffer::Make(this, sizeInBytes, type, accessPattern);
}

onCreateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1546 of file GrD3DGpu.cpp.

                                                                                     {
    return this->onCreateBackendTexture(dimensions,
                                        format,
                                        GrRenderable::kNo,
                                        mipmapped,
                                        isProtected,
                                        /*label=*/"D3DGpu_CreateCompressedBackendTexture");
}

onCreateCompressedTexture()

sk_sp< GrTexture > GrD3DGpu::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 358 of file GrD3DGpu.cpp.

                                                                      {
    DXGI_FORMAT dxgiFormat;
    SkAssertResult(format.asDxgiFormat(&dxgiFormat));
    SkASSERT(GrDxgiFormatIsCompressed(dxgiFormat));
 
    SkDEBUGCODE(SkTextureCompressionType compression = GrBackendFormatToCompressionType(format));
    SkASSERT(dataSize == SkCompressedFormatDataSize(
                                 compression, dimensions, mipmapped == skgpu::Mipmapped::kYes));
 
    int mipLevelCount = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        mipLevelCount = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
    }
    GrMipmapStatus mipmapStatus = mipLevelCount > 1 ? GrMipmapStatus::kValid
                                                    : GrMipmapStatus::kNotAllocated;
 
    sk_sp<GrD3DTexture> d3dTex = this->createD3DTexture(
        dimensions,
        dxgiFormat,
        GrRenderable::kNo,
        1,
        budgeted,
        isProtected,
        mipLevelCount,
        mipmapStatus,
        /*label=*/"D3DGpu_CreateCompressedTexture");
    if (!d3dTex) {
        return nullptr;
    }
 
    ID3D12Resource* d3dResource = d3dTex->d3dResource();
    SkASSERT(d3dResource);
    D3D12_RESOURCE_DESC desc = d3dResource->GetDesc();
    // Either upload only the first miplevel or all miplevels
    SkASSERT(1 == mipLevelCount || mipLevelCount == (int)desc.MipLevels);
 
    AutoTMalloc<D3D12_PLACED_SUBRESOURCE_FOOTPRINT> placedFootprints(mipLevelCount);
    AutoTMalloc<UINT> numRows(mipLevelCount);
    AutoTMalloc<UINT64> rowSizeInBytes(mipLevelCount);
    UINT64 combinedBufferSize;
    // We reset the width and height in the description to match our subrectangle size
    // so we don't end up allocating more space than we need.
    desc.Width = dimensions.width();
    desc.Height = dimensions.height();
    fDevice->GetCopyableFootprints(&desc, 0, mipLevelCount, 0, placedFootprints.get(),
                                   numRows.get(), rowSizeInBytes.get(), &combinedBufferSize);
    SkASSERT(combinedBufferSize);
 
    GrStagingBufferManager::Slice slice = fStagingBufferManager.allocateStagingBufferSlice(
            combinedBufferSize, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
    if (!slice.fBuffer) {
        return nullptr;
    }
 
    char* bufferData = (char*)slice.fOffsetMapPtr;
 
    copy_compressed_data(bufferData, desc.Format, placedFootprints.get(), numRows.get(),
                         rowSizeInBytes.get(), data, mipLevelCount);
 
    // Update the offsets in the footprints to be relative to the slice's offset
    for (int i = 0; i < mipLevelCount; ++i) {
        placedFootprints[i].Offset += slice.fOffset;
    }
 
    ID3D12Resource* d3dBuffer = static_cast<GrD3DBuffer*>(slice.fBuffer)->d3dResource();
    fCurrentDirectCommandList->copyBufferToTexture(d3dBuffer, d3dTex.get(), mipLevelCount,
                                                   placedFootprints.get(), 0, 0);
 
    return std::move(d3dTex);
}

onCreateTexture()

sk_sp< GrTexture > GrD3DGpu::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 309 of file GrD3DGpu.cpp.

                                                                 {
    DXGI_FORMAT dxgiFormat;
    SkAssertResult(format.asDxgiFormat(&dxgiFormat));
    SkASSERT(!GrDxgiFormatIsCompressed(dxgiFormat));
 
    GrMipmapStatus mipmapStatus = mipLevelCount > 1 ? GrMipmapStatus::kDirty
                                                    : GrMipmapStatus::kNotAllocated;
 
    sk_sp<GrD3DTexture> tex = this->createD3DTexture(dimensions, dxgiFormat, renderable,
                                                     renderTargetSampleCnt, budgeted, isProtected,
                                                     mipLevelCount, mipmapStatus, label);
    if (!tex) {
        return nullptr;
    }
 
    if (levelClearMask) {
        // TODO
    }
 
    return std::move(tex);
}

onGetOpsRenderPass()

GrOpsRenderPass * GrD3DGpu::onGetOpsRenderPass ( GrRenderTarget *  rt, bool  useMSAASurface, GrAttachment *  , 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 139 of file GrD3DGpu.cpp.

                                                   {
    if (!fCachedOpsRenderPass) {
        fCachedOpsRenderPass.reset(new GrD3DOpsRenderPass(this));
    }
 
    if (!fCachedOpsRenderPass->set(rt, origin, bounds, colorInfo, stencilInfo, sampledProxies)) {
        return nullptr;
    }
    return fCachedOpsRenderPass.get();
}

onReadPixels()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 586 of file GrD3DGpu.cpp.

                                             {
    SkASSERT(surface);
 
    if (surfaceColorType != dstColorType) {
        return false;
    }
 
    GrD3DTextureResource* texResource = nullptr;
    GrD3DRenderTarget* rt = static_cast<GrD3DRenderTarget*>(surface->asRenderTarget());
    if (rt) {
        texResource = rt;
    } else {
        texResource = static_cast<GrD3DTexture*>(surface->asTexture());
    }
 
    if (!texResource) {
        return false;
    }
 
    D3D12_RESOURCE_DESC desc = texResource->d3dResource()->GetDesc();
    D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedFootprint;
    UINT64 transferTotalBytes;
    fDevice->GetCopyableFootprints(&desc, 0, 1, 0, &placedFootprint,
                                   nullptr, nullptr, &transferTotalBytes);
    SkASSERT(transferTotalBytes);
    GrResourceProvider* resourceProvider =
        this->getContext()->priv().resourceProvider();
    sk_sp<GrGpuBuffer> transferBuffer = resourceProvider->createBuffer(
            transferTotalBytes,
            GrGpuBufferType::kXferGpuToCpu,
            kDynamic_GrAccessPattern,
            GrResourceProvider::ZeroInit::kNo);
    if (!transferBuffer) {
        return false;
    }
 
    this->readOrTransferPixels(texResource, rect, transferBuffer, placedFootprint);
    this->submitDirectCommandList(SyncQueue::kForce);
 
    // Copy back to CPU buffer
    size_t bpp = GrColorTypeBytesPerPixel(dstColorType);
    if (GrDxgiFormatBytesPerBlock(texResource->dxgiFormat()) != bpp) {
        return false;
    }
    size_t tightRowBytes = bpp * rect.width();
 
    const void* mappedMemory = transferBuffer->map();
    if (!mappedMemory) {
        return false;
    }
 
    SkRectMemcpy(buffer,
                 rowBytes,
                 mappedMemory,
                 placedFootprint.Footprint.RowPitch,
                 tightRowBytes,
                 rect.height());
 
    transferBuffer->unmap();
 
    return true;
}

onRegenerateMipMapLevels()

bool GrD3DGpu::onRegenerateMipMapLevels ( GrTexture *  tex )

overrideprivatevirtual

Implements GrGpu.

Definition at line 1104 of file GrD3DGpu.cpp.

                                                       {
    auto * d3dTex = static_cast<GrD3DTexture*>(tex);
    SkASSERT(tex->textureType() == GrTextureType::k2D);
    int width = tex->width();
    int height = tex->height();
 
    // determine if we can read from and mipmap this format
    const GrD3DCaps & caps = this->d3dCaps();
    if (!caps.isFormatTexturable(d3dTex->dxgiFormat()) ||
        !caps.mipmapSupport()) {
        return false;
    }
 
    sk_sp<GrD3DTexture> uavTexture;
    sk_sp<GrD3DTexture> bgraAliasTexture;
    DXGI_FORMAT originalFormat = d3dTex->dxgiFormat();
    D3D12_RESOURCE_DESC originalDesc = d3dTex->d3dResource()->GetDesc();
    // if the format is unordered accessible and resource flag is set, use resource for uav
    if (caps.isFormatUnorderedAccessible(originalFormat) &&
        (originalDesc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)) {
        uavTexture = sk_ref_sp(d3dTex);
    } else {
        // need to make a copy and use that for our uav
        D3D12_RESOURCE_DESC uavDesc = originalDesc;
        uavDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
        // if the format is unordered accessible, copy to resource with same format and flag set
        if (!caps.isFormatUnorderedAccessible(originalFormat)) {
            // for the BGRA and sRGB cases, we find a suitable RGBA format to use instead
            if (is_bgra(originalFormat)) {
                uavDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
                // Technically if this support is not available we should not be doing
                // aliasing. However, on Intel the BGRA and RGBA swizzle appears to be
                // the same so it still works. We may need to disable BGRA support
                // on a case-by-base basis if this doesn't hold true in general.
                if (caps.standardSwizzleLayoutSupport()) {
                    uavDesc.Layout = D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE;
                }
            // TODO: enable when sRGB shader supported
            //} else if (is_srgb(originalFormat)) {
            //    uavDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
            } else {
                return false;
            }
        }
        // TODO: make this a scratch texture
        GrProtected grProtected = tex->isProtected() ? GrProtected::kYes : GrProtected::kNo;
        uavTexture = GrD3DTexture::MakeNewTexture(this,
                                                  skgpu::Budgeted::kNo,
                                                  tex->dimensions(),
                                                  uavDesc,
                                                  grProtected,
                                                  GrMipmapStatus::kDirty,
                                                  /*label=*/"RegenerateMipMapLevels");
        if (!uavTexture) {
            return false;
        }
 
        d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_COPY_SOURCE);
        if (!caps.isFormatUnorderedAccessible(originalFormat) && is_bgra(originalFormat)) {
            // for BGRA, we alias this uavTexture with a BGRA texture and copy to that
            bgraAliasTexture = GrD3DTexture::MakeAliasingTexture(this, uavTexture, originalDesc,
                                                                 D3D12_RESOURCE_STATE_COPY_DEST);
            // make the BGRA version the active alias
            this->currentCommandList()->aliasingBarrier(nullptr,
                                                        nullptr,
                                                        bgraAliasTexture->resource(),
                                                        bgraAliasTexture->d3dResource());
            // copy top miplevel to bgraAliasTexture (should already be in COPY_DEST state)
            this->currentCommandList()->copyTextureToTexture(bgraAliasTexture.get(), d3dTex, 0);
            // make the RGBA version the active alias
            this->currentCommandList()->aliasingBarrier(bgraAliasTexture->resource(),
                                                        bgraAliasTexture->d3dResource(),
                                                        uavTexture->resource(),
                                                        uavTexture->d3dResource());
        } else {
            // copy top miplevel to uavTexture
            uavTexture->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
            this->currentCommandList()->copyTextureToTexture(uavTexture.get(), d3dTex, 0);
        }
    }
 
    uint32_t levelCount = d3dTex->mipLevels();
    // SkMipmap doesn't include the base level in the level count so we have to add 1
    SkASSERT((int)levelCount == SkMipmap::ComputeLevelCount(tex->width(), tex->height()) + 1);
 
    sk_sp<GrD3DRootSignature> rootSig = fResourceProvider.findOrCreateRootSignature(1, 1);
    this->currentCommandList()->setComputeRootSignature(rootSig);
 
    // TODO: use linear vs. srgb shader based on texture format
    sk_sp<GrD3DPipeline> pipeline = this->resourceProvider().findOrCreateMipmapPipeline();
    if (!pipeline) {
        return false;
    }
    this->currentCommandList()->setPipelineState(std::move(pipeline));
 
    // set sampler
    GrSamplerState samplerState(SkFilterMode::kLinear, SkMipmapMode::kNearest);
    std::vector<D3D12_CPU_DESCRIPTOR_HANDLE> samplers(1);
    samplers[0] = fResourceProvider.findOrCreateCompatibleSampler(samplerState);
    this->currentCommandList()->addSampledTextureRef(uavTexture.get());
    sk_sp<GrD3DDescriptorTable> samplerTable = fResourceProvider.findOrCreateSamplerTable(samplers);
 
    // Transition the top subresource to be readable in the compute shader
    D3D12_RESOURCE_STATES currentResourceState = uavTexture->currentState();
    D3D12_RESOURCE_TRANSITION_BARRIER barrier;
    barrier.pResource = uavTexture->d3dResource();
    barrier.Subresource = 0;
    barrier.StateBefore = currentResourceState;
    barrier.StateAfter = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
    this->addResourceBarriers(uavTexture->resource(), 1, &barrier);
 
    // Generate the miplevels
    for (unsigned int dstMip = 1; dstMip < levelCount; ++dstMip) {
        unsigned int srcMip = dstMip - 1;
        width = std::max(1, width / 2);
        height = std::max(1, height / 2);
 
        unsigned int sampleMode = 0;
        if (is_odd(width) && is_odd(height)) {
            sampleMode = 1;
        } else if (is_odd(width)) {
            sampleMode = 2;
        } else if (is_odd(height)) {
            sampleMode = 3;
        }
 
        // set constants
        struct {
            SkSize inverseSize;
            uint32_t mipLevel;
            uint32_t sampleMode;
        } constantData = { {1.f / width, 1.f / height}, srcMip, sampleMode };
 
        D3D12_GPU_VIRTUAL_ADDRESS constantsAddress =
            fResourceProvider.uploadConstantData(&constantData, sizeof(constantData));
        this->currentCommandList()->setComputeRootConstantBufferView(
                (unsigned int)GrD3DRootSignature::ParamIndex::kConstantBufferView,
                constantsAddress);
 
        std::vector<D3D12_CPU_DESCRIPTOR_HANDLE> shaderViews;
        // create SRV
        GrD3DDescriptorHeap::CPUHandle srvHandle =
                fResourceProvider.createShaderResourceView(uavTexture->d3dResource(), srcMip, 1);
        shaderViews.push_back(srvHandle.fHandle);
        fMipmapCPUDescriptors.push_back(srvHandle);
        // create UAV
        GrD3DDescriptorHeap::CPUHandle uavHandle =
                fResourceProvider.createUnorderedAccessView(uavTexture->d3dResource(), dstMip);
        shaderViews.push_back(uavHandle.fHandle);
        fMipmapCPUDescriptors.push_back(uavHandle);
 
        // set up shaderView descriptor table
        sk_sp<GrD3DDescriptorTable> srvTable =
                fResourceProvider.findOrCreateShaderViewTable(shaderViews);
 
        // bind both descriptor tables
        this->currentCommandList()->setDescriptorHeaps(srvTable->heap(), samplerTable->heap());
        this->currentCommandList()->setComputeRootDescriptorTable(
                (unsigned int)GrD3DRootSignature::ParamIndex::kShaderViewDescriptorTable,
                srvTable->baseGpuDescriptor());
        this->currentCommandList()->setComputeRootDescriptorTable(
                static_cast<unsigned int>(GrD3DRootSignature::ParamIndex::kSamplerDescriptorTable),
                samplerTable->baseGpuDescriptor());
 
        // Transition resource state of dstMip subresource so we can write to it
        barrier.Subresource = dstMip;
        barrier.StateBefore = currentResourceState;
        barrier.StateAfter = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
        this->addResourceBarriers(uavTexture->resource(), 1, &barrier);
 
        // Using the form (x+7)/8 ensures that the remainder is covered as well
        this->currentCommandList()->dispatch((width+7)/8, (height+7)/8);
 
        // guarantee UAV writes have completed
        this->currentCommandList()->uavBarrier(uavTexture->resource(), uavTexture->d3dResource());
 
        // Transition resource state of dstMip subresource so we can read it in the next stage
        barrier.StateBefore = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
        barrier.StateAfter = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
        this->addResourceBarriers(uavTexture->resource(), 1, &barrier);
    }
 
    // copy back if necessary
    if (uavTexture.get() != d3dTex) {
        d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
        if (bgraAliasTexture) {
            // make the BGRA version the active alias
            this->currentCommandList()->aliasingBarrier(uavTexture->resource(),
                                                        uavTexture->d3dResource(),
                                                        bgraAliasTexture->resource(),
                                                        bgraAliasTexture->d3dResource());
            // copy from bgraAliasTexture to d3dTex
            bgraAliasTexture->setResourceState(this, D3D12_RESOURCE_STATE_COPY_SOURCE);
            this->currentCommandList()->copyTextureToTexture(d3dTex, bgraAliasTexture.get());
        } else {
            barrier.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
            barrier.StateBefore = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
            barrier.StateAfter = D3D12_RESOURCE_STATE_COPY_SOURCE;
            this->addResourceBarriers(uavTexture->resource(), 1, &barrier);
            this->currentCommandList()->copyTextureToTexture(d3dTex, uavTexture.get());
        }
    } else {
        // For simplicity our resource state tracking considers all subresources to have the same
        // state. However, we've changed that state one subresource at a time without going through
        // the tracking system, so we need to patch up the resource states back to the original.
        barrier.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
        barrier.StateBefore = D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
        barrier.StateAfter = currentResourceState;
        this->addResourceBarriers(d3dTex->resource(), 1, &barrier);
    }
 
    return true;
}

onResolveRenderTarget()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 578 of file GrD3DGpu.cpp.

                                                                                       {
    SkASSERT(target->numSamples() > 1);
    GrD3DRenderTarget* rt = static_cast<GrD3DRenderTarget*>(target);
    SkASSERT(rt->msaaTextureResource() && rt != rt->msaaTextureResource());
 
    this->resolveTexture(target, resolveRect.fLeft, resolveRect.fTop, rt, resolveRect);
}

onSubmitToGpu()

bool GrD3DGpu::onSubmitToGpu ( GrSyncCpu  sync )

overrideprivatevirtual

Implements GrGpu.

Definition at line 1764 of file GrD3DGpu.cpp.

                                           {
    if (sync == GrSyncCpu::kYes) {
        return this->submitDirectCommandList(SyncQueue::kForce);
    } else {
        return this->submitDirectCommandList(SyncQueue::kSkip);
    }
}

onTransferFromBufferToBuffer()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 816 of file GrD3DGpu.cpp.

                                                         {
    if (!this->currentCommandList()) {
        return false;
    }
 
    sk_sp<GrD3DBuffer> d3dSrc(static_cast<GrD3DBuffer*>(src.release()));
    sk_sp<GrD3DBuffer> d3dDst(static_cast<GrD3DBuffer*>(dst.release()));
 
    fCurrentDirectCommandList->copyBufferToBuffer(std::move(d3dDst),
                                                  dstOffset,
                                                  d3dSrc->d3dResource(),
                                                  srcOffset,
                                                  size);
 
    // copyBufferToBuffer refs the dst but not the src
    this->currentCommandList()->addGrBuffer(std::move(src));
 
    return true;
}

onTransferPixelsFrom()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 908 of file GrD3DGpu.cpp.

                                                   {
    if (!this->currentCommandList()) {
        return false;
    }
    SkASSERT(surface);
    SkASSERT(transferBuffer);
    // TODO
    //if (fProtectedContext == GrProtected::kYes) {
    //    return false;
    //}
 
    // D3D requires offsets for texture transfers to be aligned to this value
    if (SkToBool(offset & (D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT-1))) {
        return false;
    }
 
    GrD3DTextureResource* texResource = nullptr;
    GrD3DRenderTarget* rt = static_cast<GrD3DRenderTarget*>(surface->asRenderTarget());
    if (rt) {
        texResource = rt;
    } else {
        texResource = static_cast<GrD3DTexture*>(surface->asTexture());
    }
 
    if (!texResource) {
        return false;
    }
 
    SkDEBUGCODE(DXGI_FORMAT format = texResource->dxgiFormat());
    SkASSERT(GrDxgiFormatBytesPerBlock(format) == GrColorTypeBytesPerPixel(bufferColorType));
 
    D3D12_RESOURCE_DESC desc = texResource->d3dResource()->GetDesc();
    desc.Width = rect.width();
    desc.Height = rect.height();
    D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedFootprint;
    UINT64 transferTotalBytes;
    fDevice->GetCopyableFootprints(&desc, 0, 1, offset, &placedFootprint,
                                   nullptr, nullptr, &transferTotalBytes);
    SkASSERT(transferTotalBytes);
 
    this->readOrTransferPixels(texResource, rect, transferBuffer, placedFootprint);
 
    // TODO: It's not clear how to ensure the transfer is done before we read from the buffer,
    // other than maybe doing a resource state transition.
 
    return true;
}

onTransferPixelsTo()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 840 of file GrD3DGpu.cpp.

                                                   {
    if (!this->currentCommandList()) {
        return false;
    }
 
    if (!transferBuffer) {
        return false;
    }
 
    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
    if (GrBackendFormatBytesPerPixel(texture->backendFormat()) != bpp) {
        return false;
    }
 
    // D3D requires offsets for texture transfers to be aligned to this value
    if (SkToBool(bufferOffset & (D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT-1))) {
        return false;
    }
 
    GrD3DTexture* d3dTex = static_cast<GrD3DTexture*>(texture);
    if (!d3dTex) {
        return false;
    }
 
    SkDEBUGCODE(DXGI_FORMAT format = d3dTex->dxgiFormat());
 
    // Can't transfer compressed data
    SkASSERT(!GrDxgiFormatIsCompressed(format));
 
    SkASSERT(GrDxgiFormatBytesPerBlock(format) == GrColorTypeBytesPerPixel(bufferColorType));
 
    SkASSERT(SkIRect::MakeSize(texture->dimensions()).contains(rect));
 
    // Set up copy region
    D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedFootprint = {};
    ID3D12Resource* d3dResource = d3dTex->d3dResource();
    SkASSERT(d3dResource);
    D3D12_RESOURCE_DESC desc = d3dResource->GetDesc();
    desc.Width = rect.width();
    desc.Height = rect.height();
    UINT64 totalBytes;
    fDevice->GetCopyableFootprints(&desc, 0, 1, 0, &placedFootprint,
                                   nullptr, nullptr, &totalBytes);
    placedFootprint.Offset = bufferOffset;
 
    // Change state of our target so it can be copied to
    d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
 
    // Copy the buffer to the image.
    ID3D12Resource* d3dBuffer = static_cast<GrD3DBuffer*>(transferBuffer.get())->d3dResource();
    fCurrentDirectCommandList->copyBufferToTexture(d3dBuffer,
                                                   d3dTex,
                                                   1,
                                                   &placedFootprint,
                                                   rect.left(),
                                                   rect.top());
    this->currentCommandList()->addGrBuffer(std::move(transferBuffer));
 
    d3dTex->markMipmapsDirty();
    return true;
}

onUpdateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1558 of file GrD3DGpu.cpp.

                                                             {
    GrD3DTextureResourceInfo info;
    SkAssertResult(backendTexture.getD3DTextureResourceInfo(&info));
 
    sk_sp<GrD3DResourceState> state = backendTexture.getGrD3DResourceState();
    SkASSERT(state);
    sk_sp<GrD3DTexture> texture = GrD3DTexture::MakeWrappedTexture(this,
                                                                   backendTexture.dimensions(),
                                                                   GrWrapCacheable::kNo,
                                                                   kRW_GrIOType,
                                                                   info,
                                                                   std::move(state));
    if (!texture) {
        return false;
    }
 
    GrD3DDirectCommandList* cmdList = this->currentCommandList();
    if (!cmdList) {
        return false;
    }
 
    texture->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
 
    ID3D12Resource* d3dResource = texture->d3dResource();
    SkASSERT(d3dResource);
    D3D12_RESOURCE_DESC desc = d3dResource->GetDesc();
    unsigned int mipLevelCount = 1;
    if (backendTexture.hasMipmaps()) {
        mipLevelCount = SkMipmap::ComputeLevelCount(backendTexture.dimensions().width(),
                                                    backendTexture.dimensions().height()) + 1;
    }
    SkASSERT(mipLevelCount == info.fLevelCount);
    AutoTMalloc<D3D12_PLACED_SUBRESOURCE_FOOTPRINT> placedFootprints(mipLevelCount);
    UINT64 combinedBufferSize;
    AutoTMalloc<UINT> numRows(mipLevelCount);
    AutoTMalloc<UINT64> rowSizeInBytes(mipLevelCount);
    fDevice->GetCopyableFootprints(&desc,
                                   0,
                                   mipLevelCount,
                                   0,
                                   placedFootprints.get(),
                                   numRows.get(),
                                   rowSizeInBytes.get(),
                                   &combinedBufferSize);
    SkASSERT(combinedBufferSize);
    SkASSERT(GrDxgiFormatIsCompressed(info.fFormat));
 
    GrStagingBufferManager::Slice slice = fStagingBufferManager.allocateStagingBufferSlice(
            combinedBufferSize, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
    if (!slice.fBuffer) {
        return false;
    }
 
    char* bufferData = (char*)slice.fOffsetMapPtr;
    SkASSERT(bufferData);
    copy_compressed_data(bufferData,
                         info.fFormat,
                         placedFootprints.get(),
                         numRows.get(),
                         rowSizeInBytes.get(),
                         data,
                         info.fLevelCount);
 
    // Update the offsets in the footprints to be relative to the slice's offset
    for (unsigned int i = 0; i < mipLevelCount; ++i) {
        placedFootprints[i].Offset += slice.fOffset;
    }
 
    ID3D12Resource* d3dBuffer = static_cast<GrD3DBuffer*>(slice.fBuffer)->d3dResource();
    cmdList->copyBufferToTexture(d3dBuffer,
                                 texture.get(),
                                 mipLevelCount,
                                 placedFootprints.get(),
                                 0,
                                 0);
 
    if (finishedCallback) {
        this->addFinishedCallback(std::move(finishedCallback));
    }
 
    return true;
}

onWrapBackendRenderTarget()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1056 of file GrD3DGpu.cpp.

                                                                                         {
    GrD3DTextureResourceInfo info;
    if (!rt.getD3DTextureResourceInfo(&info)) {
        return nullptr;
    }
 
    if (!check_resource_info(info)) {
        return nullptr;
    }
 
    if (!check_rt_resource_info(this->d3dCaps(), info, rt.sampleCnt())) {
        return nullptr;
    }
 
    // TODO: support protected context
    if (rt.isProtected()) {
        return nullptr;
    }
 
    sk_sp<GrD3DResourceState> state = rt.getGrD3DResourceState();
 
    sk_sp<GrD3DRenderTarget> tgt = GrD3DRenderTarget::MakeWrappedRenderTarget(
            this, rt.dimensions(), rt.sampleCnt(), info, std::move(state));
 
    // We don't allow the client to supply a premade stencil buffer. We always create one if needed.
    SkASSERT(!rt.stencilBits());
    if (tgt) {
        SkASSERT(tgt->canAttemptStencilAttachment(tgt->numSamples() > 1));
    }
 
    return std::move(tgt);
}

onWrapBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 987 of file GrD3DGpu.cpp.

                                                                 {
    GrD3DTextureResourceInfo textureInfo;
    if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
        return nullptr;
    }
 
    if (!check_resource_info(textureInfo)) {
        return nullptr;
    }
 
    if (!check_tex_resource_info(this->d3dCaps(), textureInfo)) {
        return nullptr;
    }
 
    // TODO: support protected context
    if (tex.isProtected()) {
        return nullptr;
    }
 
    sk_sp<GrD3DResourceState> state = tex.getGrD3DResourceState();
    SkASSERT(state);
    return GrD3DTexture::MakeWrappedTexture(this, tex.dimensions(), wrapType, ioType, textureInfo,
                                            std::move(state));
}

onWrapCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1015 of file GrD3DGpu.cpp.

                                                                                    {
    return this->onWrapBackendTexture(tex, ownership, wrapType, kRead_GrIOType);
}

onWrapRenderableBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1021 of file GrD3DGpu.cpp.

                                                                                     {
    GrD3DTextureResourceInfo textureInfo;
    if (!tex.getD3DTextureResourceInfo(&textureInfo)) {
        return nullptr;
    }
 
    if (!check_resource_info(textureInfo)) {
        return nullptr;
    }
 
    if (!check_tex_resource_info(this->d3dCaps(), textureInfo)) {
        return nullptr;
    }
    if (!check_rt_resource_info(this->d3dCaps(), textureInfo, sampleCnt)) {
        return nullptr;
    }
 
    // TODO: support protected context
    if (tex.isProtected()) {
        return nullptr;
    }
 
    sampleCnt = this->d3dCaps().getRenderTargetSampleCount(sampleCnt, textureInfo.fFormat);
 
    sk_sp<GrD3DResourceState> state = tex.getGrD3DResourceState();
    SkASSERT(state);
 
    return GrD3DTextureRenderTarget::MakeWrappedTextureRenderTarget(this, tex.dimensions(),
                                                                    sampleCnt, cacheable,
                                                                    textureInfo, std::move(state));
}

onWritePixels()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 688 of file GrD3DGpu.cpp.

                                                      {
    GrD3DTexture* d3dTex = static_cast<GrD3DTexture*>(surface->asTexture());
    if (!d3dTex) {
        return false;
    }
 
    // Make sure we have at least the base level
    if (!mipLevelCount || !texels[0].fPixels) {
        return false;
    }
 
    SkASSERT(!GrDxgiFormatIsCompressed(d3dTex->dxgiFormat()));
    bool success = false;
 
    // Need to change the resource state to COPY_DEST in order to upload to it
    d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_COPY_DEST);
 
    SkASSERT(mipLevelCount <= d3dTex->maxMipmapLevel() + 1);
    success = this->uploadToTexture(d3dTex, rect, srcColorType, texels, mipLevelCount);
 
    if (prepForTexSampling) {
        d3dTex->setResourceState(this, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
    }
 
    return success;
}

pipelineBuilder()

GrThreadSafePipelineBuilder * GrD3DGpu::pipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 41 of file GrD3DGpu.cpp.

                                                       {
    return nullptr;
}

prepareSurfacesForBackendAccessAndStateUpdates()

void GrD3DGpu::prepareSurfacesForBackendAccessAndStateUpdates ( SkSpan< GrSurfaceProxy * >  proxies, SkSurfaces::BackendSurfaceAccess  access, const skgpu::MutableTextureState *  newState  )

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 1739 of file GrD3DGpu.cpp.

                                                  {
    // prepare proxies by transitioning to PRESENT renderState
    if (!proxies.empty() && access == SkSurfaces::BackendSurfaceAccess::kPresent) {
        GrD3DTextureResource* resource;
        for (GrSurfaceProxy* proxy : proxies) {
            SkASSERT(proxy->isInstantiated());
            if (GrTexture* tex = proxy->peekTexture()) {
                resource = static_cast<GrD3DTexture*>(tex);
            } else {
                GrRenderTarget* rt = proxy->peekRenderTarget();
                SkASSERT(rt);
                resource = static_cast<GrD3DRenderTarget*>(rt);
            }
            resource->prepareForPresent(this);
        }
    }
}

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.

{ return false; }

queue()

ID3D12CommandQueue * GrD3DGpu::queue ( ) const

inline

Definition at line 44 of file GrD3DGpu.h.

{ 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.

{ return fResourceProvider; }

stagingBufferManager()

GrStagingBufferManager * GrD3DGpu::stagingBufferManager ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 50 of file GrD3DGpu.h.

{ 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.

{ 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.

{}

---

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