#include <GrD3DCommandList.h>

Inheritance diagram for GrD3DDirectCommandList:

Public Member Functions
	~GrD3DDirectCommandList () override=default

void	setPipelineState (const sk_sp< GrD3DPipeline > &pipeline)

void	setStencilRef (unsigned int stencilRef)

void	setBlendFactor (const float blendFactor[4])

void	setPrimitiveTopology (D3D12_PRIMITIVE_TOPOLOGY primitiveTopology)

void	setScissorRects (unsigned int numRects, const D3D12_RECT *rects)

void	setViewports (unsigned int numViewports, const D3D12_VIEWPORT *viewports)

void	setGraphicsRootSignature (const sk_sp< GrD3DRootSignature > &rootSignature)

void	setComputeRootSignature (const sk_sp< GrD3DRootSignature > &rootSignature)

void	setVertexBuffers (unsigned int startSlot, sk_sp< const GrBuffer > vertexBuffer, size_t vertexStride, sk_sp< const GrBuffer > instanceBuffer, size_t instanceStride)

void	setIndexBuffer (sk_sp< const GrBuffer > indexBuffer)

void	drawInstanced (unsigned int vertexCount, unsigned int instanceCount, unsigned int startVertex, unsigned int startInstance)

void	drawIndexedInstanced (unsigned int indexCount, unsigned int instanceCount, unsigned int startIndex, unsigned int baseVertex, unsigned int startInstance)

void	executeIndirect (const sk_sp< GrD3DCommandSignature > commandSig, unsigned int maxCommandCnt, const GrD3DBuffer *argumentBuffer, size_t argumentBufferOffset)

void	dispatch (unsigned int threadGroupCountX, unsigned int threadGroupCountY, unsigned int threadGroupCountZ=1)

void	clearRenderTargetView (const GrD3DRenderTarget renderTarget, std::array< float, 4 > color, const D3D12_RECT rect)

void	clearDepthStencilView (const GrD3DAttachment , uint8_t stencilClearValue, const D3D12_RECT rect)

void	setRenderTarget (const GrD3DRenderTarget *renderTarget)

void	resolveSubresourceRegion (const GrD3DTextureResource dstTexture, unsigned int dstX, unsigned int dstY, const GrD3DTextureResource srcTexture, D3D12_RECT *srcRect)

void	setGraphicsRootConstantBufferView (unsigned int rootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS bufferLocation)

void	setGraphicsRootDescriptorTable (unsigned int rootParameterIndex, D3D12_GPU_DESCRIPTOR_HANDLE bufferLocation)

void	setComputeRootConstantBufferView (unsigned int rootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS bufferLocation)

void	setComputeRootDescriptorTable (unsigned int rootParameterIndex, D3D12_GPU_DESCRIPTOR_HANDLE bufferLocation)

void	setDescriptorHeaps (ID3D12DescriptorHeap srvDescriptorHeap, ID3D12DescriptorHeap samplerDescriptorHeap)

void	addSampledTextureRef (GrD3DTexture *)

Public Member Functions inherited from GrD3DCommandList
virtual	~GrD3DCommandList ()

SubmitResult	submit (ID3D12CommandQueue *queue)

bool	close ()

void	reset ()

void	resourceBarrier (sk_sp< GrManagedResource > managedResource, int numBarriers, const D3D12_RESOURCE_TRANSITION_BARRIER *barriers)

void	uavBarrier (sk_sp< GrManagedResource > managedResource, ID3D12Resource *uavResource)

void	aliasingBarrier (sk_sp< GrManagedResource > beforeManagedResource, ID3D12Resource beforeResource, sk_sp< GrManagedResource > afterManagedResource, ID3D12Resource afterResource)

void	copyBufferToTexture (ID3D12Resource srcBuffer, const GrD3DTextureResource dstTexture, uint32_t subresourceCount, D3D12_PLACED_SUBRESOURCE_FOOTPRINT *bufferFootprints, int left, int top)

void	copyTextureRegionToTexture (sk_sp< GrManagedResource > dst, const D3D12_TEXTURE_COPY_LOCATION dstLocation, UINT dstX, UINT dstY, sk_sp< GrManagedResource > src, const D3D12_TEXTURE_COPY_LOCATION srcLocation, const D3D12_BOX *srcBox)

void	copyTextureRegionToBuffer (sk_sp< const GrBuffer > dst, const D3D12_TEXTURE_COPY_LOCATION dstLocation, UINT dstX, UINT dstY, sk_sp< GrManagedResource > src, const D3D12_TEXTURE_COPY_LOCATION srcLocation, const D3D12_BOX *srcBox)

void	copyTextureToTexture (const GrD3DTexture dst, const GrD3DTexture src, UINT subresourceIndex=-1)

void	copyBufferToBuffer (sk_sp< GrD3DBuffer > dstBuffer, uint64_t dstOffset, ID3D12Resource *srcBuffer, uint64_t srcOffset, uint64_t numBytes)

void	addGrBuffer (sk_sp< const GrBuffer > buffer)

void	addRecycledResource (sk_sp< GrRecycledResource > resource)

void	releaseResources ()

bool	hasWork () const

void	addFinishedCallback (sk_sp< skgpu::RefCntedCallback > callback)

Static Public Member Functions
static std::unique_ptr< GrD3DDirectCommandList >	Make (GrD3DGpu *gpu)

Private Member Functions
void	onReset () override

Additional Inherited Members
Public Types inherited from GrD3DCommandList
enum class	SubmitResult { kNoWork , kSuccess , kFailure }

Protected Types inherited from GrD3DCommandList
template<typename T >
using	TrackedResourceArray = skia_private::STArray< kInitialTrackedResourcesCount, T >

Protected Member Functions inherited from GrD3DCommandList
	GrD3DCommandList (gr_cp< ID3D12CommandAllocator > allocator, gr_cp< ID3D12GraphicsCommandList > commandList)

void	addResource (sk_sp< GrManagedResource > resource)

void	addingWork ()

void	submitResourceBarriers ()

	SkDEBUGCODE (bool fIsActive=true;) bool fHasWork

Protected Attributes inherited from GrD3DCommandList
gr_cp< ID3D12GraphicsCommandList >	fCommandList

TrackedResourceArray< sk_sp< GrManagedResource > >	fTrackedResources

TrackedResourceArray< sk_sp< GrRecycledResource > >	fTrackedRecycledResources

TrackedResourceArray< sk_sp< const GrBuffer > >	fTrackedGpuBuffers

Detailed Description

Definition at line 158 of file GrD3DCommandList.h.

Constructor & Destructor Documentation

◆ ~GrD3DDirectCommandList()

GrD3DDirectCommandList::~GrD3DDirectCommandList ( )

overridedefault

Member Function Documentation

◆ addSampledTextureRef()

void GrD3DDirectCommandList::addSampledTextureRef ( GrD3DTexture * texture )

Definition at line 592 of file GrD3DCommandList.cpp.

                                                                       {
    this->addResource(texture->resource());
}

◆ clearDepthStencilView()

void GrD3DDirectCommandList::clearDepthStencilView	(	const GrD3DAttachment *	stencil,
		uint8_t	stencilClearValue,
		const D3D12_RECT *	rect
	)

Definition at line 473 of file GrD3DCommandList.cpp.

                                                                           {
    this->addingWork();
    this->addResource(stencil->resource());
    unsigned int numRects = rect ? 1 : 0;
    fCommandList->ClearDepthStencilView(stencil->view(), D3D12_CLEAR_FLAG_STENCIL, 0,
                                        stencilClearValue, numRects, rect);
}

◆ clearRenderTargetView()

void GrD3DDirectCommandList::clearRenderTargetView	(	const GrD3DRenderTarget *	renderTarget,
		std::array< float, 4 >	color,
		const D3D12_RECT *	rect
	)

Definition at line 459 of file GrD3DCommandList.cpp.

                                                                           {
    this->addingWork();
    this->addResource(renderTarget->resource());
    const GrD3DTextureResource* msaaTextureResource = renderTarget->msaaTextureResource();
    if (msaaTextureResource && msaaTextureResource != renderTarget) {
        this->addResource(msaaTextureResource->resource());
    }
    unsigned int numRects = rect ? 1 : 0;
    fCommandList->ClearRenderTargetView(renderTarget->colorRenderTargetView(), color.data(),
                                        numRects, rect);
}

◆ dispatch()

void GrD3DDirectCommandList::dispatch	(	unsigned int	threadGroupCountX,
		unsigned int	threadGroupCountY,
		unsigned int	threadGroupCountZ = `1`
	)

Definition at line 451 of file GrD3DCommandList.cpp.

                                                                      {
    SkASSERT(fIsActive);
    this->addingWork();
    fCommandList->Dispatch(threadGroupCountX, threadGroupCountY, threadGroupCountZ);
}

◆ drawIndexedInstanced()

void GrD3DDirectCommandList::drawIndexedInstanced	(	unsigned int	indexCount,
		unsigned int	instanceCount,
		unsigned int	startIndex,
		unsigned int	baseVertex,
		unsigned int	startInstance
	)

Definition at line 426 of file GrD3DCommandList.cpp.

                                                                              {
    SkASSERT(fIsActive);
    this->addingWork();
    fCommandList->DrawIndexedInstanced(indexCount, instanceCount, startIndex, baseVertex,
                                       startInstance);
}

◆ drawInstanced()

void GrD3DDirectCommandList::drawInstanced	(	unsigned int	vertexCount,
		unsigned int	instanceCount,
		unsigned int	startVertex,
		unsigned int	startInstance
	)

Definition at line 419 of file GrD3DCommandList.cpp.

                                                                                                 {
    SkASSERT(fIsActive);
    this->addingWork();
    fCommandList->DrawInstanced(vertexCount, instanceCount, startVertex, startInstance);
}

◆ executeIndirect()

void GrD3DDirectCommandList::executeIndirect	(	const sk_sp< GrD3DCommandSignature >	commandSig,
		unsigned int	maxCommandCnt,
		const GrD3DBuffer *	argumentBuffer,
		size_t	argumentBufferOffset
	)

Definition at line 437 of file GrD3DCommandList.cpp.

                                                                          {
    SkASSERT(fIsActive);
    this->addingWork();
    this->addResource(commandSignature);
    fCommandList->ExecuteIndirect(commandSignature->commandSignature(), maxCommandCount,
                                  argumentBuffer->d3dResource(), argumentBufferOffset,
                                  nullptr, 0);
    this->addGrBuffer(sk_ref_sp<const GrBuffer>(argumentBuffer));
}

◆ Make()

std::unique_ptr< GrD3DDirectCommandList > GrD3DDirectCommandList::Make ( GrD3DGpu * gpu )

static

Definition at line 270 of file GrD3DCommandList.cpp.

                                                                                {
    ID3D12Device* device = gpu->device();
    gr_cp<ID3D12CommandAllocator> allocator;
    GR_D3D_CALL_ERRCHECK(device->CreateCommandAllocator(
                         D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&allocator)));
 
    gr_cp<ID3D12GraphicsCommandList> commandList;
    GR_D3D_CALL_ERRCHECK(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT,
                                                   allocator.get(), nullptr,
                                                   IID_PPV_ARGS(&commandList)));
 
    auto grCL = new GrD3DDirectCommandList(std::move(allocator), std::move(commandList),
                                           gpu->d3dCaps().resolveSubresourceRegionSupport());
    return std::unique_ptr<GrD3DDirectCommandList>(grCL);
}

◆ onReset()

void GrD3DDirectCommandList::onReset ( )

overrideprivatevirtual

Reimplemented from GrD3DCommandList.

Definition at line 295 of file GrD3DCommandList.cpp.

                                     {
    fCurrentPipeline = nullptr;
    fCurrentGraphicsRootSignature = nullptr;
    fCurrentComputeRootSignature = nullptr;
    fCurrentVertexBuffer = nullptr;
    fCurrentVertexStride = 0;
    fCurrentInstanceBuffer = nullptr;
    fCurrentInstanceStride = 0;
    fCurrentIndexBuffer = nullptr;
    fCurrentGraphicsConstantBufferAddress = 0;
    fCurrentComputeConstantBufferAddress = 0;
    sk_bzero(fCurrentGraphicsRootDescTable, sizeof(fCurrentGraphicsRootDescTable));
    sk_bzero(fCurrentComputeRootDescTable, sizeof(fCurrentComputeRootDescTable));
    fCurrentSRVCRVDescriptorHeap = nullptr;
    fCurrentSamplerDescriptorHeap = nullptr;
}

◆ resolveSubresourceRegion()

void GrD3DDirectCommandList::resolveSubresourceRegion	(	const GrD3DTextureResource *	dstTexture,
		unsigned int	dstX,
		unsigned int	dstY,
		const GrD3DTextureResource *	srcTexture,
		D3D12_RECT *	srcRect
	)

Definition at line 504 of file GrD3DCommandList.cpp.

                                                                           {
    SkASSERT(dstTexture->dxgiFormat() == srcTexture->dxgiFormat());
    SkASSERT(dstTexture->currentState() == D3D12_RESOURCE_STATE_RESOLVE_DEST);
    SkASSERT(srcTexture->currentState() == D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
    this->addingWork();
    this->addResource(dstTexture->resource());
    this->addResource(srcTexture->resource());
 
    if (fResolveSubregionSupported) {
        gr_cp<ID3D12GraphicsCommandList1> commandList1;
        HRESULT result = fCommandList->QueryInterface(IID_PPV_ARGS(&commandList1));
        if (SUCCEEDED(result)) {
            commandList1->ResolveSubresourceRegion(dstTexture->d3dResource(), 0, dstX, dstY,
                                                   srcTexture->d3dResource(), 0, srcRect,
                                                   srcTexture->dxgiFormat(),
                                                   D3D12_RESOLVE_MODE_AVERAGE);
            return;
        }
    }
 
    fCommandList->ResolveSubresource(dstTexture->d3dResource(), 0, srcTexture->d3dResource(), 0,
                                     srcTexture->dxgiFormat());
}

◆ setBlendFactor()

void GrD3DDirectCommandList::setBlendFactor ( const float blendFactor[4] )

Definition at line 326 of file GrD3DCommandList.cpp.

                                                                      {
    SkASSERT(fIsActive);
    fCommandList->OMSetBlendFactor(blendFactor);
}

◆ setComputeRootConstantBufferView()

void GrD3DDirectCommandList::setComputeRootConstantBufferView	(	unsigned int	rootParameterIndex,
		D3D12_GPU_VIRTUAL_ADDRESS	bufferLocation
	)

Definition at line 541 of file GrD3DCommandList.cpp.

                                                                               {
    SkASSERT(rootParameterIndex ==
             (unsigned int)GrD3DRootSignature::ParamIndex::kConstantBufferView);
    if (bufferLocation != fCurrentComputeConstantBufferAddress) {
        fCommandList->SetComputeRootConstantBufferView(rootParameterIndex, bufferLocation);
        fCurrentComputeConstantBufferAddress = bufferLocation;
    }
}

◆ setComputeRootDescriptorTable()

void GrD3DDirectCommandList::setComputeRootDescriptorTable	(	unsigned int	rootParameterIndex,
		D3D12_GPU_DESCRIPTOR_HANDLE	bufferLocation
	)

Definition at line 563 of file GrD3DCommandList.cpp.

                                                                                 {
    SkASSERT(rootParameterIndex ==
             (unsigned int)GrD3DRootSignature::ParamIndex::kSamplerDescriptorTable ||
             rootParameterIndex ==
             (unsigned int)GrD3DRootSignature::ParamIndex::kShaderViewDescriptorTable);
    if (fCurrentComputeRootDescTable[rootParameterIndex].ptr != baseDescriptor.ptr) {
        fCommandList->SetComputeRootDescriptorTable(rootParameterIndex, baseDescriptor);
        fCurrentComputeRootDescTable[rootParameterIndex] = baseDescriptor;
    }
}

◆ setComputeRootSignature()

void GrD3DDirectCommandList::setComputeRootSignature ( const sk_sp< GrD3DRootSignature > & rootSignature )

Definition at line 358 of file GrD3DCommandList.cpp.

                                                                                             {
    SkASSERT(fIsActive);
    if (fCurrentComputeRootSignature != rootSig.get()) {
        fCommandList->SetComputeRootSignature(rootSig->rootSignature());
        this->addResource(rootSig);
        fCurrentComputeRootSignature = rootSig.get();
        // need to reset the current descriptor tables as well
        sk_bzero(fCurrentComputeRootDescTable, sizeof(fCurrentComputeRootDescTable));
    }
}

◆ setDescriptorHeaps()

void GrD3DDirectCommandList::setDescriptorHeaps	(	ID3D12DescriptorHeap *	srvDescriptorHeap,
		ID3D12DescriptorHeap *	samplerDescriptorHeap
	)

Definition at line 577 of file GrD3DCommandList.cpp.

                                                                                             {
    if (srvCrvDescriptorHeap != fCurrentSRVCRVDescriptorHeap ||
        samplerDescriptorHeap != fCurrentSamplerDescriptorHeap) {
        ID3D12DescriptorHeap* heaps[2] = {
            srvCrvDescriptorHeap,
            samplerDescriptorHeap
        };
 
        fCommandList->SetDescriptorHeaps(2, heaps);
        fCurrentSRVCRVDescriptorHeap = srvCrvDescriptorHeap;
        fCurrentSamplerDescriptorHeap = samplerDescriptorHeap;
    }
}

◆ setGraphicsRootConstantBufferView()

void GrD3DDirectCommandList::setGraphicsRootConstantBufferView	(	unsigned int	rootParameterIndex,
		D3D12_GPU_VIRTUAL_ADDRESS	bufferLocation
	)

Definition at line 531 of file GrD3DCommandList.cpp.

                                                                                   {
    SkASSERT(rootParameterIndex ==
                (unsigned int) GrD3DRootSignature::ParamIndex::kConstantBufferView);
    if (bufferLocation != fCurrentGraphicsConstantBufferAddress) {
        fCommandList->SetGraphicsRootConstantBufferView(rootParameterIndex, bufferLocation);
        fCurrentGraphicsConstantBufferAddress = bufferLocation;
    }
}

◆ setGraphicsRootDescriptorTable()

void GrD3DDirectCommandList::setGraphicsRootDescriptorTable	(	unsigned int	rootParameterIndex,
		D3D12_GPU_DESCRIPTOR_HANDLE	bufferLocation
	)

Definition at line 551 of file GrD3DCommandList.cpp.

                                                                                     {
    SkASSERT(rootParameterIndex ==
                    (unsigned int)GrD3DRootSignature::ParamIndex::kSamplerDescriptorTable ||
             rootParameterIndex ==
                    (unsigned int)GrD3DRootSignature::ParamIndex::kShaderViewDescriptorTable);
    if (fCurrentGraphicsRootDescTable[rootParameterIndex].ptr != baseDescriptor.ptr) {
        fCommandList->SetGraphicsRootDescriptorTable(rootParameterIndex, baseDescriptor);
        fCurrentGraphicsRootDescTable[rootParameterIndex] = baseDescriptor;
    }
}

◆ setGraphicsRootSignature()

void GrD3DDirectCommandList::setGraphicsRootSignature ( const sk_sp< GrD3DRootSignature > & rootSignature )

Definition at line 347 of file GrD3DCommandList.cpp.

                                                                                              {
    SkASSERT(fIsActive);
    if (fCurrentGraphicsRootSignature != rootSig.get()) {
        fCommandList->SetGraphicsRootSignature(rootSig->rootSignature());
        this->addResource(rootSig);
        fCurrentGraphicsRootSignature = rootSig.get();
        // need to reset the current descriptor tables as well
        sk_bzero(fCurrentGraphicsRootDescTable, sizeof(fCurrentGraphicsRootDescTable));
    }
}

◆ setIndexBuffer()

void GrD3DDirectCommandList::setIndexBuffer ( sk_sp< const GrBuffer > indexBuffer )

Definition at line 404 of file GrD3DCommandList.cpp.

                                                                             {
    if (fCurrentIndexBuffer != indexBuffer.get()) {
        auto* d3dBuffer = static_cast<const GrD3DBuffer*>(indexBuffer.get());
 
        D3D12_INDEX_BUFFER_VIEW view = {};
        view.BufferLocation = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
        view.SizeInBytes = indexBuffer->size();
        view.Format = DXGI_FORMAT_R16_UINT;
        fCommandList->IASetIndexBuffer(&view);
 
        fCurrentIndexBuffer = indexBuffer.get();
        this->addGrBuffer(std::move(indexBuffer));
    }
}

◆ setPipelineState()

void GrD3DDirectCommandList::setPipelineState ( const sk_sp< GrD3DPipeline > & pipeline )

Definition at line 312 of file GrD3DCommandList.cpp.

                                                                                  {
    SkASSERT(fIsActive);
    if (pipeline.get() != fCurrentPipeline) {
        fCommandList->SetPipelineState(pipeline->d3dPipelineState());
        this->addResource(std::move(pipeline));
        fCurrentPipeline = pipeline.get();
    }
}

◆ setPrimitiveTopology()

void GrD3DDirectCommandList::setPrimitiveTopology ( D3D12_PRIMITIVE_TOPOLOGY primitiveTopology )

Definition at line 331 of file GrD3DCommandList.cpp.

                                                                                            {
    SkASSERT(fIsActive);
    fCommandList->IASetPrimitiveTopology(primitiveTopology);
}

◆ setRenderTarget()

void GrD3DDirectCommandList::setRenderTarget ( const GrD3DRenderTarget * renderTarget )

Definition at line 483 of file GrD3DCommandList.cpp.

                                                                                  {
    this->addingWork();
    this->addResource(renderTarget->resource());
    const GrD3DTextureResource* msaaTextureResource = renderTarget->msaaTextureResource();
    if (msaaTextureResource && msaaTextureResource != renderTarget) {
        this->addResource(msaaTextureResource->resource());
    }
    D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = renderTarget->colorRenderTargetView();
 
    D3D12_CPU_DESCRIPTOR_HANDLE dsDescriptor;
    D3D12_CPU_DESCRIPTOR_HANDLE* dsDescriptorPtr = nullptr;
    if (auto stencil = renderTarget->getStencilAttachment()) {
        GrD3DAttachment* d3dStencil = static_cast<GrD3DAttachment*>(stencil);
        this->addResource(d3dStencil->resource());
        dsDescriptor = d3dStencil->view();
        dsDescriptorPtr = &dsDescriptor;
    }
 
    fCommandList->OMSetRenderTargets(1, &rtvDescriptor, false, dsDescriptorPtr);
}

◆ setScissorRects()

void GrD3DDirectCommandList::setScissorRects	(	unsigned int	numRects,
		const D3D12_RECT *	rects
	)

Definition at line 336 of file GrD3DCommandList.cpp.

                                                                                           {
    SkASSERT(fIsActive);
    fCommandList->RSSetScissorRects(numRects, rects);
}

◆ setStencilRef()

void GrD3DDirectCommandList::setStencilRef ( unsigned int stencilRef )

Definition at line 321 of file GrD3DCommandList.cpp.

                                                                  {
    SkASSERT(fIsActive);
    fCommandList->OMSetStencilRef(stencilRef);
}

◆ setVertexBuffers()

void GrD3DDirectCommandList::setVertexBuffers	(	unsigned int	startSlot,
		sk_sp< const GrBuffer >	vertexBuffer,
		size_t	vertexStride,
		sk_sp< const GrBuffer >	instanceBuffer,
		size_t	instanceStride
	)

Definition at line 369 of file GrD3DCommandList.cpp.

                                                                     {
    if (fCurrentVertexBuffer != vertexBuffer.get() ||
        fCurrentVertexStride != vertexStride ||
        fCurrentInstanceBuffer != instanceBuffer.get() ||
        fCurrentInstanceStride != instanceStride) {
 
        fCurrentVertexBuffer = vertexBuffer.get();
        fCurrentVertexStride = vertexStride;
        fCurrentInstanceBuffer = instanceBuffer.get();
        fCurrentInstanceStride = instanceStride;
 
        D3D12_VERTEX_BUFFER_VIEW views[2];
        int numViews = 0;
        if (vertexBuffer) {
            auto* d3dBuffer = static_cast<const GrD3DBuffer*>(vertexBuffer.get());
            views[numViews].BufferLocation = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
            views[numViews].SizeInBytes = vertexBuffer->size();
            views[numViews++].StrideInBytes = vertexStride;
            this->addGrBuffer(std::move(vertexBuffer));
        }
        if (instanceBuffer) {
            auto* d3dBuffer = static_cast<const GrD3DBuffer*>(instanceBuffer.get());
            views[numViews].BufferLocation = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
            views[numViews].SizeInBytes = instanceBuffer->size();
            views[numViews++].StrideInBytes = instanceStride;
            this->addGrBuffer(std::move(instanceBuffer));
        }
        fCommandList->IASetVertexBuffers(startSlot, numViews, views);
    }
}

◆ setViewports()

void GrD3DDirectCommandList::setViewports	(	unsigned int	numViewports,
		const D3D12_VIEWPORT *	viewports
	)

Definition at line 341 of file GrD3DCommandList.cpp.

                                                                           {
    SkASSERT(fIsActive);
    fCommandList->RSSetViewports(numViewports, viewports);
}

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

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members