GrOpFlushState Class Reference

#include <GrOpFlushState.h>

Inheritance diagram for GrOpFlushState:

Classes
struct	OpArgs

Public Member Functions
	GrOpFlushState (GrGpu *, GrResourceProvider *, skgpu::TokenTracker *, sk_sp< GrBufferAllocPool::CpuBufferCache >=nullptr)
	~GrOpFlushState () final
void	preExecuteDraws ()
void	doUpload (GrDeferredTextureUploadFn &, bool shouldPrepareSurfaceForSampling=false)
void	executeDrawsAndUploadsForMeshDrawOp (const GrOp *op, const SkRect &chainBounds, const GrPipeline *, const GrUserStencilSettings *)
GrOpsRenderPass *	opsRenderPass ()
void	setOpsRenderPass (GrOpsRenderPass *renderPass)
GrGpu *	gpu ()
void	reset ()
void	setOpArgs (OpArgs *opArgs)
const OpArgs &	drawOpArgs () const
void	setSampledProxyArray (skia_private::TArray< GrSurfaceProxy *, true > *sampledProxies)
skia_private::TArray< GrSurfaceProxy *, true > *	sampledProxyArray () override
const skgpu::TokenTracker *	tokenTracker () final
skgpu::AtlasToken	addInlineUpload (GrDeferredTextureUploadFn &&) final
skgpu::AtlasToken	addASAPUpload (GrDeferredTextureUploadFn &&) final
void	recordDraw (const GrGeometryProcessor *, const GrSimpleMesh[], int meshCnt, const GrSurfaceProxy *const primProcProxies[], GrPrimitiveType) final
void *	makeVertexSpace (size_t vertexSize, int vertexCount, sk_sp< const GrBuffer > *, int *startVertex) final
uint16_t *	makeIndexSpace (int indexCount, sk_sp< const GrBuffer > *, int *startIndex) final
void *	makeVertexSpaceAtLeast (size_t vertexSize, int minVertexCount, int fallbackVertexCount, sk_sp< const GrBuffer > *, int *startVertex, int *actualVertexCount) final
uint16_t *	makeIndexSpaceAtLeast (int minIndexCount, int fallbackIndexCount, sk_sp< const GrBuffer > *, int *startIndex, int *actualIndexCount) final
GrDrawIndirectWriter	makeDrawIndirectSpace (int drawCount, sk_sp< const GrBuffer > *buffer, size_t *offset) override
GrDrawIndexedIndirectWriter	makeDrawIndexedIndirectSpace (int drawCount, sk_sp< const GrBuffer > *buffer, size_t *offset) override
void	putBackIndices (int indexCount) final
void	putBackVertices (int vertices, size_t vertexStride) final
void	putBackIndirectDraws (int drawCount) final
void	putBackIndexedIndirectDraws (int drawCount) final
const GrSurfaceProxyView &	writeView () const final
GrRenderTargetProxy *	rtProxy () const final
bool	usesMSAASurface () const final
const GrAppliedClip *	appliedClip () const final
const GrAppliedHardClip &	appliedHardClip () const
GrAppliedClip	detachAppliedClip () final
const GrDstProxyView &	dstProxyView () const final
GrXferBarrierFlags	renderPassBarriers () const final
GrLoadOp	colorLoadOp () const final
GrDeferredUploadTarget *	deferredUploadTarget () final
const GrCaps &	caps () const final
GrThreadSafeCache *	threadSafeCache () const final
GrResourceProvider *	resourceProvider () const final
sktext::gpu::StrikeCache *	strikeCache () const final
GrAtlasManager *	atlasManager () const final
skgpu::ganesh::SmallPathAtlasMgr *	smallPathAtlasManager () const final
SkArenaAlloc *	allocator () override
void	bindPipelineAndScissorClip (const GrProgramInfo &programInfo, const SkRect &drawBounds)
void	bindTextures (const GrGeometryProcessor &geomProc, const GrSurfaceProxy &singleGeomProcTexture, const GrPipeline &pipeline)
void	drawMesh (const GrSimpleMesh &mesh)
void	bindPipeline (const GrProgramInfo &programInfo, const SkRect &drawBounds)
void	setScissorRect (const SkIRect &scissorRect)
void	bindTextures (const GrGeometryProcessor &geomProc, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &pipeline)
void	bindBuffers (sk_sp< const GrBuffer > indexBuffer, sk_sp< const GrBuffer > instanceBuffer, sk_sp< const GrBuffer > vertexBuffer, GrPrimitiveRestart primitiveRestart=GrPrimitiveRestart::kNo)
void	draw (int vertexCount, int baseVertex)
void	drawIndexed (int indexCount, int baseIndex, uint16_t minIndexValue, uint16_t maxIndexValue, int baseVertex)
void	drawInstanced (int instanceCount, int baseInstance, int vertexCount, int baseVertex)
void	drawIndexedInstanced (int indexCount, int baseIndex, int instanceCount, int baseInstance, int baseVertex)
void	drawIndirect (const GrBuffer *drawIndirectBuffer, size_t offset, int drawCount)
void	drawIndexedIndirect (const GrBuffer *drawIndirectBuffer, size_t offset, int drawCount)
void	drawIndexPattern (int patternIndexCount, int patternRepeatCount, int maxPatternRepetitionsInIndexBuffer, int patternVertexCount, int baseVertex)
Public Member Functions inherited from GrDeferredUploadTarget
virtual	~GrDeferredUploadTarget ()
Public Member Functions inherited from GrMeshDrawTarget
virtual	~GrMeshDrawTarget ()
void	recordDraw (const GrGeometryProcessor *gp, const GrSimpleMesh meshes[], int meshCnt, GrPrimitiveType primitiveType)
skgpu::VertexWriter	makeVertexWriter (size_t vertexSize, int vertexCount, sk_sp< const GrBuffer > *, int *startVertex)
skgpu::IndexWriter	makeIndexWriter (int indexCount, sk_sp< const GrBuffer > *, int *startIndex)
skgpu::VertexWriter	makeVertexWriterAtLeast (size_t vertexSize, int minVertexCount, int fallbackVertexCount, sk_sp< const GrBuffer > *, int *startVertex, int *actualVertexCount)
skgpu::IndexWriter	makeIndexWriterAtLeast (int minIndexCount, int fallbackIndexCount, sk_sp< const GrBuffer > *, int *startIndex, int *actualIndexCount)
GrSimpleMesh *	allocMesh ()
GrSimpleMesh *	allocMeshes (int n)
const GrSurfaceProxy **	allocPrimProcProxyPtrs (int n)
uint32_t	contextUniqueID () const

Detailed Description

Tracks the state across all the GrOps (really just the GrDrawOps) in a OpsTask flush.

Definition at line 58 of file GrOpFlushState.h.

Constructor & Destructor Documentation

GrOpFlushState()

GrOpFlushState::GrOpFlushState	(	GrGpu *	gpu,
		GrResourceProvider *	resourceProvider,
		skgpu::TokenTracker *	tokenTracker,
		sk_sp< GrBufferAllocPool::CpuBufferCache >	cpuBufferCache = nullptr
	)

Definition at line 31 of file GrOpFlushState.cpp.

        : fVertexPool(gpu, cpuBufferCache)
        , fIndexPool(gpu, cpuBufferCache)
        , fDrawIndirectPool(gpu, std::move(cpuBufferCache))
        , fGpu(gpu)
        , fResourceProvider(resourceProvider)
        , fTokenTracker(tokenTracker) {}

~GrOpFlushState()

GrOpFlushState::~GrOpFlushState ( )

inlinefinal

Definition at line 66 of file GrOpFlushState.h.

{ this->reset(); }

Member Function Documentation

addASAPUpload()

skgpu::AtlasToken GrOpFlushState::addASAPUpload ( GrDeferredTextureUploadFn &&  upload )

finalvirtual

Returns the token of the draw that this upload will occur before. Since ASAP uploads are done first during a flush, this will be the first token since the most recent flush.

Implements GrDeferredUploadTarget.

Definition at line 157 of file GrOpFlushState.cpp.

                                                                                {
    fASAPUploads.append(&fArena, std::move(upload));
    return fTokenTracker->nextFlushToken();
}

addInlineUpload()

skgpu::AtlasToken GrOpFlushState::addInlineUpload ( GrDeferredTextureUploadFn &&  )

finalvirtual

Returns the token of the draw that this upload will occur before.

Implements GrDeferredUploadTarget.

Definition at line 152 of file GrOpFlushState.cpp.

                                                                                  {
    return fInlineUploads.append(&fArena, std::move(upload), fTokenTracker->nextDrawToken())
            .fUploadBeforeToken;
}

allocator()

SkArenaAlloc * GrOpFlushState::allocator ( )

inlineoverridevirtual

GrMeshDrawTarget override.

Implements GrMeshDrawTarget.

Definition at line 223 of file GrOpFlushState.h.

{ return &fArena; }

appliedClip()

const GrAppliedClip * GrOpFlushState::appliedClip ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 190 of file GrOpFlushState.h.

{ return this->drawOpArgs().appliedClip(); }

appliedHardClip()

const GrAppliedHardClip & GrOpFlushState::appliedHardClip ( ) const

inline

Definition at line 191 of file GrOpFlushState.h.

                                                     {
        return (fOpArgs->appliedClip()) ?
                fOpArgs->appliedClip()->hardClip() : GrAppliedHardClip::Disabled();
    }

atlasManager()

GrAtlasManager * GrOpFlushState::atlasManager ( ) const

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 228 of file GrOpFlushState.cpp.

                                                   {
    return fGpu->getContext()->priv().getAtlasManager();
}

bindBuffers()

void GrOpFlushState::bindBuffers ( sk_sp< const GrBuffer >  indexBuffer, sk_sp< const GrBuffer >  instanceBuffer, sk_sp< const GrBuffer >  vertexBuffer, GrPrimitiveRestart  primitiveRestart = GrPrimitiveRestart::kNo  )

inline

Definition at line 261 of file GrOpFlushState.h.

                                                                                  {
        fOpsRenderPass->bindBuffers(std::move(indexBuffer), std::move(instanceBuffer),
                                    std::move(vertexBuffer), primitiveRestart);
    }

bindPipeline()

void GrOpFlushState::bindPipeline ( const GrProgramInfo &  programInfo, const SkRect &  drawBounds  )

inline

Definition at line 250 of file GrOpFlushState.h.

                                                                                  {
        fOpsRenderPass->bindPipeline(programInfo, drawBounds);
    }

bindPipelineAndScissorClip()

void GrOpFlushState::bindPipelineAndScissorClip ( const GrProgramInfo &  programInfo, const SkRect &  drawBounds  )

inline

Definition at line 227 of file GrOpFlushState.h.

                                                                                                {
        SkASSERT((programInfo.pipeline().isScissorTestEnabled()) ==
                 (this->appliedClip() && this->appliedClip()->scissorState().enabled()));
        this->bindPipeline(programInfo, drawBounds);
        if (programInfo.pipeline().isScissorTestEnabled()) {
            this->setScissorRect(this->appliedClip()->scissorState().rect());
        }
    }

bindTextures() [1/2]

void GrOpFlushState::bindTextures ( const GrGeometryProcessor &  geomProc, const GrSurfaceProxy &  singleGeomProcTexture, const GrPipeline &  pipeline  )

inline

Definition at line 238 of file GrOpFlushState.h.

                                                  {
        SkASSERT(geomProc.numTextureSamplers() == 1);
        const GrSurfaceProxy* ptr = &singleGeomProcTexture;
        this->bindTextures(geomProc, &ptr, pipeline);
    }

bindTextures() [2/2]

void GrOpFlushState::bindTextures ( const GrGeometryProcessor &  geomProc, const GrSurfaceProxy *const  geomProcTextures[], const GrPipeline &  pipeline  )

inline

Definition at line 256 of file GrOpFlushState.h.

                                                  {
        fOpsRenderPass->bindTextures(geomProc, geomProcTextures, pipeline);
    }

caps()

const GrCaps & GrOpFlushState::caps ( ) const

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 41 of file GrOpFlushState.cpp.

                                         {
    return *fGpu->caps();
}

colorLoadOp()

GrLoadOp GrOpFlushState::colorLoadOp ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 204 of file GrOpFlushState.h.

                                       {
        return this->drawOpArgs().colorLoadOp();
    }

deferredUploadTarget()

GrDeferredUploadTarget * GrOpFlushState::deferredUploadTarget ( )

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 208 of file GrOpFlushState.h.

{ return this; }

detachAppliedClip()

GrAppliedClip GrOpFlushState::detachAppliedClip ( )

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 220 of file GrOpFlushState.cpp.

                                                {
    return fOpArgs->appliedClip() ? std::move(*fOpArgs->appliedClip()) : GrAppliedClip::Disabled();
}

doUpload()

void GrOpFlushState::doUpload	(	GrDeferredTextureUploadFn &	upload,
		bool	shouldPrepareSurfaceForSampling = false
	)

Called to upload data to a texture using the GrDeferredTextureUploadFn. If the uploaded surface needs to be prepared for being sampled in a draw after the upload, the caller should pass in true for shouldPrepareSurfaceForSampling. This feature is needed for Vulkan when doing inline uploads to reset the image layout back to sampled.

Definition at line 110 of file GrOpFlushState.cpp.

                                                                    {
    GrDeferredTextureUploadWritePixelsFn wp = [this, shouldPrepareSurfaceForSampling](
                                                      GrTextureProxy* dstProxy,
                                                      SkIRect rect,
                                                      GrColorType colorType,
                                                      const void* buffer,
                                                      size_t rowBytes) {
        GrSurface* dstSurface = dstProxy->peekSurface();
        if (!fGpu->caps()->surfaceSupportsWritePixels(dstSurface)) {
            return false;
        }
        GrCaps::SupportedWrite supportedWrite = fGpu->caps()->supportedWritePixelsColorType(
                colorType, dstSurface->backendFormat(), colorType);
        size_t tightRB = rect.width()*GrColorTypeBytesPerPixel(supportedWrite.fColorType);
        SkASSERT(rowBytes >= tightRB);
        std::unique_ptr<char[]> tmpPixels;
        if (supportedWrite.fColorType != colorType ||
            (!fGpu->caps()->writePixelsRowBytesSupport() && rowBytes != tightRB)) {
            tmpPixels.reset(new char[rect.height()*tightRB]);
            // Use kUnknown to ensure no alpha type conversions or clamping occur.
            static constexpr auto kAT = kUnknown_SkAlphaType;
            GrImageInfo srcInfo(colorType,                 kAT, nullptr, rect.size());
            GrImageInfo tmpInfo(supportedWrite.fColorType, kAT, nullptr, rect.size());
            if (!GrConvertPixels( GrPixmap(tmpInfo, tmpPixels.get(), tightRB ),
                                 GrCPixmap(srcInfo,          buffer, rowBytes))) {
                return false;
            }
            rowBytes = tightRB;
            buffer = tmpPixels.get();
        }
        return this->fGpu->writePixels(dstSurface,
                                       rect,
                                       colorType,
                                       supportedWrite.fColorType,
                                       buffer,
                                       rowBytes,
                                       shouldPrepareSurfaceForSampling);
    };
    upload(wp);
}

draw()

void GrOpFlushState::draw ( int  vertexCount, int  baseVertex  )

inline

Definition at line 267 of file GrOpFlushState.h.

                                               {
        fOpsRenderPass->draw(vertexCount, baseVertex);
    }

drawIndexed()

void GrOpFlushState::drawIndexed ( int  indexCount, int  baseIndex, uint16_t  minIndexValue, uint16_t  maxIndexValue, int  baseVertex  )

inline

Definition at line 270 of file GrOpFlushState.h.

                                     {
        fOpsRenderPass->drawIndexed(indexCount, baseIndex, minIndexValue, maxIndexValue,
                                    baseVertex);
    }

drawIndexedIndirect()

void GrOpFlushState::drawIndexedIndirect ( const GrBuffer *  drawIndirectBuffer, size_t  offset, int  drawCount  )

inline

Definition at line 286 of file GrOpFlushState.h.

                                                                                               {
        fOpsRenderPass->drawIndexedIndirect(drawIndirectBuffer, offset, drawCount);
    }

drawIndexedInstanced()

void GrOpFlushState::drawIndexedInstanced ( int  indexCount, int  baseIndex, int  instanceCount, int  baseInstance, int  baseVertex  )

inline

Definition at line 278 of file GrOpFlushState.h.

                                              {
        fOpsRenderPass->drawIndexedInstanced(indexCount, baseIndex, instanceCount, baseInstance,
                                             baseVertex);
    }

drawIndexPattern()

void GrOpFlushState::drawIndexPattern ( int  patternIndexCount, int  patternRepeatCount, int  maxPatternRepetitionsInIndexBuffer, int  patternVertexCount, int  baseVertex  )

inline

Definition at line 289 of file GrOpFlushState.h.

                                          {
        fOpsRenderPass->drawIndexPattern(patternIndexCount, patternRepeatCount,
                                         maxPatternRepetitionsInIndexBuffer, patternVertexCount,
                                         baseVertex);
    }

drawIndirect()

void GrOpFlushState::drawIndirect ( const GrBuffer *  drawIndirectBuffer, size_t  offset, int  drawCount  )

inline

Definition at line 283 of file GrOpFlushState.h.

                                                                                        {
        fOpsRenderPass->drawIndirect(drawIndirectBuffer, offset, drawCount);
    }

drawInstanced()

void GrOpFlushState::drawInstanced ( int  instanceCount, int  baseInstance, int  vertexCount, int  baseVertex  )

inline

Definition at line 275 of file GrOpFlushState.h.

                                                                                             {
        fOpsRenderPass->drawInstanced(instanceCount, baseInstance, vertexCount, baseVertex);
    }

drawMesh()

void GrOpFlushState::drawMesh

(

const GrSimpleMesh &

mesh

)

Definition at line 238 of file GrOpFlushState.cpp.

                                                      {
    SkASSERT(mesh.fIsInitialized);
    if (!mesh.fIndexBuffer) {
        this->bindBuffers(nullptr, nullptr, mesh.fVertexBuffer);
        this->draw(mesh.fVertexCount, mesh.fBaseVertex);
    } else {
        this->bindBuffers(mesh.fIndexBuffer, nullptr, mesh.fVertexBuffer, mesh.fPrimitiveRestart);
        if (0 == mesh.fPatternRepeatCount) {
            this->drawIndexed(mesh.fIndexCount, mesh.fBaseIndex, mesh.fMinIndexValue,
                              mesh.fMaxIndexValue, mesh.fBaseVertex);
        } else {
            this->drawIndexPattern(mesh.fIndexCount, mesh.fPatternRepeatCount,
                                   mesh.fMaxPatternRepetitionsInIndexBuffer, mesh.fVertexCount,
                                   mesh.fBaseVertex);
        }
    }
}

drawOpArgs()

const OpArgs & GrOpFlushState::drawOpArgs ( ) const

inline

Definition at line 137 of file GrOpFlushState.h.

                                     {
        SkASSERT(fOpArgs);
        SkDEBUGCODE(fOpArgs->validate());
        return *fOpArgs;
    }

dstProxyView()

const GrDstProxyView & GrOpFlushState::dstProxyView ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 196 of file GrOpFlushState.h.

                                                     {
        return this->drawOpArgs().dstProxyView();
    }

executeDrawsAndUploadsForMeshDrawOp()

void GrOpFlushState::executeDrawsAndUploadsForMeshDrawOp	(	const GrOp *	op,
		const SkRect &	chainBounds,
		const GrPipeline *	pipeline,
		const GrUserStencilSettings *	userStencilSettings
	)

Called as ops are executed. Must be called in the same order as the ops were prepared.

Definition at line 49 of file GrOpFlushState.cpp.

                                                          {
    SkASSERT(this->opsRenderPass());
 
    while (fCurrDraw != fDraws.end() && fCurrDraw->fOp == op) {
        skgpu::AtlasToken drawToken = fTokenTracker->nextFlushToken();
        while (fCurrUpload != fInlineUploads.end() &&
               fCurrUpload->fUploadBeforeToken == drawToken) {
            this->opsRenderPass()->inlineUpload(this, fCurrUpload->fUpload);
            ++fCurrUpload;
        }
 
        GrProgramInfo programInfo(this->caps(),
                                  this->writeView(),
                                  this->usesMSAASurface(),
                                  pipeline,
                                  userStencilSettings,
                                  fCurrDraw->fGeometryProcessor,
                                  fCurrDraw->fPrimitiveType,
                                  this->renderPassBarriers(),
                                  this->colorLoadOp());
 
        this->bindPipelineAndScissorClip(programInfo, chainBounds);
        this->bindTextures(programInfo.geomProc(), fCurrDraw->fGeomProcProxies,
                           programInfo.pipeline());
        for (int i = 0; i < fCurrDraw->fMeshCnt; ++i) {
            this->drawMesh(fCurrDraw->fMeshes[i]);
        }
 
        fTokenTracker->issueFlushToken();
        ++fCurrDraw;
    }
}

gpu()

GrGpu * GrOpFlushState::gpu ( )

inline

Definition at line 85 of file GrOpFlushState.h.

{ return fGpu; }

makeDrawIndexedIndirectSpace()

GrDrawIndexedIndirectWriter GrOpFlushState::makeDrawIndexedIndirectSpace ( int  drawCount, sk_sp< const GrBuffer > *  , size_t *  offsetInBytes  )

inlineoverridevirtual

Makes space for elements in a draw-indexed-indirect buffer. Upon success, the returned pointer is a CPU mapping where the data should be written.

Implements GrMeshDrawTarget.

Definition at line 176 of file GrOpFlushState.h.

                                                                                      {
        return fDrawIndirectPool.makeIndexedSpace(drawCount, buffer, offset);
    }

makeDrawIndirectSpace()

GrDrawIndirectWriter GrOpFlushState::makeDrawIndirectSpace ( int  drawCount, sk_sp< const GrBuffer > *  buffer, size_t *  offsetInBytes  )

inlineoverridevirtual

Makes space for elements in a draw-indirect buffer. Upon success, the returned pointer is a CPU mapping where the data should be written.

Implements GrMeshDrawTarget.

Definition at line 172 of file GrOpFlushState.h.

                                                                        {
        return fDrawIndirectPool.makeSpace(drawCount, buffer, offset);
    }

makeIndexSpace()

uint16_t * GrOpFlushState::makeIndexSpace ( int  indexCount, sk_sp< const GrBuffer > *  , int *  startIndex  )

finalvirtual

Makes space for index data. The returned pointer is the location where index data should be written. On return the buffer that will hold the data as well as an offset into the buffer (in uint16_t units) where the data will be placed.

Implements GrMeshDrawTarget.

Definition at line 193 of file GrOpFlushState.cpp.

                                                          {
    return reinterpret_cast<uint16_t*>(fIndexPool.makeSpace(indexCount, buffer, startIndex));
}

makeIndexSpaceAtLeast()

uint16_t * GrOpFlushState::makeIndexSpaceAtLeast ( int  minIndexCount, int  fallbackIndexCount, sk_sp< const GrBuffer > *  , int *  startIndex, int *  actualIndexCount  )

finalvirtual

This is similar to makeIndexSpace. It allows the caller to use up to 'actualIndexCount' indices in the returned pointer, which may exceed 'minIndexCount'. 'fallbackIndexCount' is the maximum number of indices that should be allocated if a new buffer is allocated on behalf of this request.

Implements GrMeshDrawTarget.

Definition at line 205 of file GrOpFlushState.cpp.

                                                                       {
    return reinterpret_cast<uint16_t*>(fIndexPool.makeSpaceAtLeast(
            minIndexCount, fallbackIndexCount, buffer, startIndex, actualIndexCount));
}

makeVertexSpace()

void * GrOpFlushState::makeVertexSpace ( size_t  vertexSize, int  vertexCount, sk_sp< const GrBuffer > *  , int *  startVertex  )

finalvirtual

Makes space for vertex data. The returned pointer is the location where vertex data should be written. On return the buffer that will hold the data as well as an offset into the buffer (in 'vertexSize' units) where the data will be placed.

Implements GrMeshDrawTarget.

Definition at line 188 of file GrOpFlushState.cpp.

                                                                                       {
    return fVertexPool.makeSpace(vertexSize, vertexCount, buffer, startVertex);
}

makeVertexSpaceAtLeast()

void * GrOpFlushState::makeVertexSpaceAtLeast ( size_t  vertexSize, int  minVertexCount, int  fallbackVertexCount, sk_sp< const GrBuffer > *  , int *  startVertex, int *  actualVertexCount  )

finalvirtual

This is similar to makeVertexSpace. It allows the caller to use up to 'actualVertexCount' vertices in the returned pointer, which may exceed 'minVertexCount'. 'fallbackVertexCount' is the maximum number of vertices that should be allocated if a new buffer is allocated on behalf of this request.

Implements GrMeshDrawTarget.

Definition at line 198 of file GrOpFlushState.cpp.

                                                                                       {
    return fVertexPool.makeSpaceAtLeast(vertexSize, minVertexCount, fallbackVertexCount, buffer,
                                        startVertex, actualVertexCount);
}

opsRenderPass()

GrOpsRenderPass * GrOpFlushState::opsRenderPass ( )

inline

Definition at line 82 of file GrOpFlushState.h.

{ return fOpsRenderPass; }

preExecuteDraws()

void GrOpFlushState::preExecuteDraws

(

)

This is called after each op has a chance to prepare its draws and before the draws are executed.

Definition at line 84 of file GrOpFlushState.cpp.

                                     {
    fVertexPool.unmap();
    fIndexPool.unmap();
    fDrawIndirectPool.unmap();
    for (auto& upload : fASAPUploads) {
        this->doUpload(upload);
    }
    // Setup execution iterators.
    fCurrDraw = fDraws.begin();
    fCurrUpload = fInlineUploads.begin();
    fGpu->willExecute();
}

putBackIndexedIndirectDraws()

void GrOpFlushState::putBackIndexedIndirectDraws ( int  drawCount )

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 184 of file GrOpFlushState.h.

                                                          {
        fDrawIndirectPool.putBackIndexed(drawCount);
    }

putBackIndices()

void GrOpFlushState::putBackIndices ( int  indices )

finalvirtual

Helpers for ops which over-allocate and then return excess data to the pool.

Implements GrMeshDrawTarget.

Definition at line 212 of file GrOpFlushState.cpp.

                                                  {
    fIndexPool.putBack(indexCount * sizeof(uint16_t));
}

putBackIndirectDraws()

void GrOpFlushState::putBackIndirectDraws ( int  drawCount )

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 183 of file GrOpFlushState.h.

{ fDrawIndirectPool.putBack(drawCount); }

putBackVertices()

void GrOpFlushState::putBackVertices ( int  vertices, size_t  vertexStride  )

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 216 of file GrOpFlushState.cpp.

                                                                      {
    fVertexPool.putBack(vertices * vertexStride);
}

recordDraw()

void GrOpFlushState::recordDraw ( const GrGeometryProcessor *  geomProc, const GrSimpleMesh  meshes[], int  meshCnt, const GrSurfaceProxy *const  primProcProxies[], GrPrimitiveType  primitiveType  )

finalvirtual

Overrides of GrMeshDrawTarget.

Implements GrMeshDrawTarget.

Definition at line 162 of file GrOpFlushState.cpp.

                                       {
    SkASSERT(fOpArgs);
    SkDEBUGCODE(fOpArgs->validate());
    bool firstDraw = fDraws.begin() == fDraws.end();
    auto& draw = fDraws.append(&fArena);
    skgpu::AtlasToken token = fTokenTracker->issueDrawToken();
    for (int i = 0; i < geomProc->numTextureSamplers(); ++i) {
        SkASSERT(geomProcProxies && geomProcProxies[i]);
        geomProcProxies[i]->ref();
    }
    draw.fGeometryProcessor = geomProc;
    draw.fGeomProcProxies = geomProcProxies;
    draw.fMeshes = meshes;
    draw.fMeshCnt = meshCnt;
    draw.fOp = fOpArgs->op();
    draw.fPrimitiveType = primitiveType;
    if (firstDraw) {
        fBaseDrawToken = token;
    }
}

renderPassBarriers()

GrXferBarrierFlags GrOpFlushState::renderPassBarriers ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 200 of file GrOpFlushState.h.

                                                        {
        return this->drawOpArgs().renderPassBarriers();
    }

reset()

void GrOpFlushState::reset

(

)

Definition at line 97 of file GrOpFlushState.cpp.

                           {
    SkASSERT(fCurrDraw == fDraws.end());
    SkASSERT(fCurrUpload == fInlineUploads.end());
    fVertexPool.reset();
    fIndexPool.reset();
    fDrawIndirectPool.reset();
    fArena.reset();
    fASAPUploads.reset();
    fInlineUploads.reset();
    fDraws.reset();
    fBaseDrawToken = skgpu::AtlasToken::InvalidToken();
}

resourceProvider()

GrResourceProvider * GrOpFlushState::resourceProvider ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 211 of file GrOpFlushState.h.

{ return fResourceProvider; }

rtProxy()

GrRenderTargetProxy * GrOpFlushState::rtProxy ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 188 of file GrOpFlushState.h.

{ return this->drawOpArgs().rtProxy(); }

sampledProxyArray()

skia_private::TArray< GrSurfaceProxy *, true > * GrOpFlushState::sampledProxyArray ( )

inlineoverridevirtual

Implements GrMeshDrawTarget.

Definition at line 147 of file GrOpFlushState.h.

                                                                            {
        return fSampledProxies;
    }

setOpArgs()

void GrOpFlushState::setOpArgs ( OpArgs *  opArgs )

inline

Definition at line 135 of file GrOpFlushState.h.

{ fOpArgs = opArgs; }

setOpsRenderPass()

void GrOpFlushState::setOpsRenderPass ( GrOpsRenderPass *  renderPass )

inline

Definition at line 83 of file GrOpFlushState.h.

{ fOpsRenderPass = renderPass; }

setSampledProxyArray()

void GrOpFlushState::setSampledProxyArray ( skia_private::TArray< GrSurfaceProxy *, true > *  sampledProxies )

inline

Definition at line 143 of file GrOpFlushState.h.

                                                                                         {
        fSampledProxies = sampledProxies;
    }

setScissorRect()

void GrOpFlushState::setScissorRect ( const SkIRect &  scissorRect )

inline

Definition at line 253 of file GrOpFlushState.h.

                                                    {
        fOpsRenderPass->setScissorRect(scissorRect);
    }

smallPathAtlasManager()

skgpu::ganesh::SmallPathAtlasMgr * GrOpFlushState::smallPathAtlasManager ( ) const

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 233 of file GrOpFlushState.cpp.

                                                                          {
    return fGpu->getContext()->priv().getSmallPathAtlasMgr();
}

strikeCache()

sktext::gpu::StrikeCache * GrOpFlushState::strikeCache ( ) const

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 224 of file GrOpFlushState.cpp.

                                                        {
    return fGpu->getContext()->priv().getStrikeCache();
}

threadSafeCache()

GrThreadSafeCache * GrOpFlushState::threadSafeCache ( ) const

finalvirtual

Implements GrMeshDrawTarget.

Definition at line 45 of file GrOpFlushState.cpp.

                                                         {
    return fGpu->getContext()->priv().threadSafeCache();
}

tokenTracker()

const skgpu::TokenTracker * GrOpFlushState::tokenTracker ( )

inlinefinalvirtual

Overrides of GrDeferredUploadTarget.

Implements GrDeferredUploadTarget.

Definition at line 153 of file GrOpFlushState.h.

{ return fTokenTracker; }

usesMSAASurface()

bool GrOpFlushState::usesMSAASurface ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 189 of file GrOpFlushState.h.

{ return this->drawOpArgs().usesMSAASurface(); }

writeView()

const GrSurfaceProxyView & GrOpFlushState::writeView ( ) const

inlinefinalvirtual

Implements GrMeshDrawTarget.

Definition at line 187 of file GrOpFlushState.h.

{ return this->drawOpArgs().writeView(); }

---

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

• third_party/skia/src/gpu/ganesh/GrOpFlushState.h
• third_party/skia/src/gpu/ganesh/GrOpFlushState.cpp