GrGLOpsRenderPass Class Reference

#include <GrGLOpsRenderPass.h>

Inheritance diagram for GrGLOpsRenderPass:

Public Member Functions
	GrGLOpsRenderPass (GrGLGpu *gpu)
void	inlineUpload (GrOpFlushState *state, GrDeferredTextureUploadFn &upload) override
void	set (GrRenderTarget *, bool useMSAASurface, const SkIRect &contentBounds, GrSurfaceOrigin, const LoadAndStoreInfo &, const StencilLoadAndStoreInfo &)
void	reset ()
Public Member Functions inherited from GrOpsRenderPass
virtual	~GrOpsRenderPass ()
void	begin ()
void	end ()
void	bindPipeline (const GrProgramInfo &, const SkRect &drawBounds)
void	setScissorRect (const SkIRect &)
void	bindTextures (const GrGeometryProcessor &, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &)
void	bindBuffers (sk_sp< const GrBuffer > indexBuffer, sk_sp< const GrBuffer > instanceBuffer, sk_sp< const GrBuffer > vertexBuffer, GrPrimitiveRestart=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 bufferOffset, int drawCount)
void	drawIndexedIndirect (const GrBuffer *drawIndirectBuffer, size_t bufferOffset, int drawCount)
void	drawIndexPattern (int patternIndexCount, int patternRepeatCount, int maxPatternRepetitionsInIndexBuffer, int patternVertexCount, int baseVertex)
void	clear (const GrScissorState &scissor, std::array< float, 4 > color)
void	clearStencilClip (const GrScissorState &scissor, bool insideStencilMask)
void	executeDrawable (std::unique_ptr< SkDrawable::GpuDrawHandler >)

Private Member Functions
GrGpu *	gpu () override
void	onBegin () override
void	onEnd () override
bool	onBindPipeline (const GrProgramInfo &programInfo, const SkRect &drawBounds) override
void	onSetScissorRect (const SkIRect &scissor) override
bool	onBindTextures (const GrGeometryProcessor &, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &) override
void	onBindBuffers (sk_sp< const GrBuffer > indexBuffer, sk_sp< const GrBuffer > instanceBuffer, sk_sp< const GrBuffer > vertexBuffer, GrPrimitiveRestart) override
void	onDraw (int vertexCount, int baseVertex) override
void	onDrawIndexed (int indexCount, int baseIndex, uint16_t minIndexValue, uint16_t maxIndexValue, int baseVertex) override
void	onDrawInstanced (int instanceCount, int baseInstance, int vertexCount, int baseVertex) override
void	onDrawIndexedInstanced (int indexCount, int baseIndex, int instanceCount, int baseInstance, int baseVertex) override
void	onDrawIndirect (const GrBuffer *drawIndirectBuffer, size_t offset, int drawCount) override
void	onDrawIndexedIndirect (const GrBuffer *drawIndirectBuffer, size_t offset, int drawCount) override
void	onClear (const GrScissorState &scissor, std::array< float, 4 > color) override
void	onClearStencilClip (const GrScissorState &scissor, bool insideStencilMask) override

Additional Inherited Members
Protected Member Functions inherited from GrOpsRenderPass
	GrOpsRenderPass ()
	GrOpsRenderPass (GrRenderTarget *rt, GrSurfaceOrigin origin)
void	set (GrRenderTarget *rt, GrSurfaceOrigin origin)
Protected Attributes inherited from GrOpsRenderPass
GrSurfaceOrigin	fOrigin
GrRenderTarget *	fRenderTarget
sk_sp< const GrBuffer >	fActiveIndexBuffer
sk_sp< const GrBuffer >	fActiveVertexBuffer
sk_sp< const GrBuffer >	fActiveInstanceBuffer

Detailed Description

Definition at line 20 of file GrGLOpsRenderPass.h.

Constructor & Destructor Documentation

GrGLOpsRenderPass()

GrGLOpsRenderPass::GrGLOpsRenderPass ( GrGLGpu *  gpu )

inline

We do not actually buffer up draws or do any work in the this class for GL. Instead commands are immediately sent to the gpu to execute. Thus all the commands in this class are simply pass through functions to corresponding calls in the GrGLGpu class.

Definition at line 27 of file GrGLOpsRenderPass.h.

: fGpu(gpu) {}

Member Function Documentation

gpu()

GrGpu * GrGLOpsRenderPass::gpu ( )

inlineoverrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 41 of file GrGLOpsRenderPass.h.

{ return fGpu; }

inlineUpload()

void GrGLOpsRenderPass::inlineUpload ( GrOpFlushState *  state, GrDeferredTextureUploadFn &  upload  )

inlineoverridevirtual

Implements GrOpsRenderPass.

Definition at line 29 of file GrGLOpsRenderPass.h.

                                                                                         {
        state->doUpload(upload);
    }

onBegin()

void GrGLOpsRenderPass::onBegin ( )

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 48 of file GrGLOpsRenderPass.cpp.

                                {
    auto glRT = static_cast<GrGLRenderTarget*>(fRenderTarget);
    if (fUseMultisampleFBO &&
        fColorLoadAndStoreInfo.fLoadOp == GrLoadOp::kLoad &&
        glRT->hasDynamicMSAAAttachment()) {
        // Load the single sample fbo into the dmsaa attachment.
        if (fGpu->glCaps().canResolveSingleToMSAA()) {
            fGpu->resolveRenderFBOs(glRT, this->dmsaaLoadStoreBounds().asSkIRect(),
                                    GrGLGpu::ResolveDirection::kSingleToMSAA);
        } else {
            fGpu->drawSingleIntoMSAAFBO(glRT, this->dmsaaLoadStoreBounds().asSkIRect());
        }
    }
 
    fGpu->beginCommandBuffer(glRT, fUseMultisampleFBO, fContentBounds, fOrigin,
                             fColorLoadAndStoreInfo, fStencilLoadAndStoreInfo);
}

onBindBuffers()

void GrGLOpsRenderPass::onBindBuffers ( sk_sp< const GrBuffer >  indexBuffer, sk_sp< const GrBuffer >  instanceBuffer, sk_sp< const GrBuffer >  vertexBuffer, GrPrimitiveRestart  primitiveRestart  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 100 of file GrGLOpsRenderPass.cpp.

                                                                           {
    SkASSERT((primitiveRestart == GrPrimitiveRestart::kNo) || indexBuffer);
    GrGLProgram* program = fGpu->currentProgram();
    SkASSERT(program);
 
#ifdef SK_DEBUG
    fDidBindInstanceBuffer = false;
    fDidBindVertexBuffer = false;
#endif
 
    int numAttribs = program->numVertexAttributes() + program->numInstanceAttributes();
    fAttribArrayState = fGpu->bindInternalVertexArray(indexBuffer.get(), numAttribs,
                                                      primitiveRestart);
 
    if (indexBuffer) {
        if (indexBuffer->isCpuBuffer()) {
            auto* cpuIndexBuffer = static_cast<const GrCpuBuffer*>(indexBuffer.get());
            fIndexPointer = reinterpret_cast<const uint16_t*>(cpuIndexBuffer->data());
        } else {
            fIndexPointer = nullptr;
        }
    }
 
    // If this platform does not support baseInstance, defer binding of the instance buffer.
    if (fGpu->glCaps().baseVertexBaseInstanceSupport()) {
        this->bindInstanceBuffer(instanceBuffer.get(), 0);
        SkDEBUGCODE(fDidBindInstanceBuffer = true;)
    }
    fActiveInstanceBuffer = std::move(instanceBuffer);
 
    // We differ binding the vertex buffer for one of two situations:
    // 1) This platform does not support baseVertex with indexed draws.
    // 2) There is a driver bug affecting glDrawArrays.
    if ((indexBuffer && fGpu->glCaps().baseVertexBaseInstanceSupport()) ||
        (!indexBuffer && !fGpu->glCaps().drawArraysBaseVertexIsBroken())) {
            this->bindVertexBuffer(vertexBuffer.get(), 0);
            SkDEBUGCODE(fDidBindVertexBuffer = true;)
    }
    fActiveVertexBuffer = std::move(vertexBuffer);
    fActiveIndexBuffer = std::move(indexBuffer);
}

onBindPipeline()

bool GrGLOpsRenderPass::onBindPipeline ( const GrProgramInfo &  programInfo, const SkRect &  drawBounds  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 81 of file GrGLOpsRenderPass.cpp.

                                                                 {
    fPrimitiveType = programInfo.primitiveType();
    return fGpu->flushGLState(fRenderTarget, fUseMultisampleFBO, programInfo);
}

onBindTextures()

bool GrGLOpsRenderPass::onBindTextures ( const GrGeometryProcessor &  geomProc, const GrSurfaceProxy *const  geomProcTextures[], const GrPipeline &  pipeline  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 91 of file GrGLOpsRenderPass.cpp.

                                                                   {
    GrGLProgram* program = fGpu->currentProgram();
    SkASSERT(program);
    program->bindTextures(geomProc, geomProcTextures, pipeline);
    return true;
}

onClear()

void GrGLOpsRenderPass::onClear ( const GrScissorState &  scissor, std::array< float, 4 >  color  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 433 of file GrGLOpsRenderPass.cpp.

                                                                                       {
    fGpu->clear(scissor, color, fRenderTarget, fUseMultisampleFBO, fOrigin);
}

onClearStencilClip()

void GrGLOpsRenderPass::onClearStencilClip ( const GrScissorState &  scissor, bool  insideStencilMask  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 437 of file GrGLOpsRenderPass.cpp.

                                                                                                {
    fGpu->clearStencilClip(scissor, insideStencilMask, fRenderTarget, fUseMultisampleFBO, fOrigin);
}

onDraw()

void GrGLOpsRenderPass::onDraw ( int  vertexCount, int  baseVertex  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 182 of file GrGLOpsRenderPass.cpp.

                                                              {
    SkASSERT(fDidBindVertexBuffer || fGpu->glCaps().drawArraysBaseVertexIsBroken());
    GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
    if (fGpu->glCaps().drawArraysBaseVertexIsBroken()) {
        this->bindVertexBuffer(fActiveVertexBuffer.get(), baseVertex);
        baseVertex = 0;
    }
    GL_CALL(DrawArrays(glPrimType, baseVertex, vertexCount));
    fGpu->didDrawTo(fRenderTarget);
}

onDrawIndexed()

void GrGLOpsRenderPass::onDrawIndexed ( int  indexCount, int  baseIndex, uint16_t  minIndexValue, uint16_t  maxIndexValue, int  baseVertex  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 193 of file GrGLOpsRenderPass.cpp.

                                                                              {
    GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
    if (fGpu->glCaps().baseVertexBaseInstanceSupport()) {
        SkASSERT(fGpu->glCaps().drawInstancedSupport());
        SkASSERT(fDidBindVertexBuffer);
        if (baseVertex != 0) {
            GL_CALL(DrawElementsInstancedBaseVertexBaseInstance(
                    glPrimType, indexCount, GR_GL_UNSIGNED_SHORT,
                    this->offsetForBaseIndex(baseIndex), 1, baseVertex, 0));
            return;
        }
    } else {
        this->bindVertexBuffer(fActiveVertexBuffer.get(), baseVertex);
    }
 
    if (fGpu->glCaps().drawRangeElementsSupport()) {
        GL_CALL(DrawRangeElements(glPrimType, minIndexValue, maxIndexValue, indexCount,
                                  GR_GL_UNSIGNED_SHORT, this->offsetForBaseIndex(baseIndex)));
    } else {
        GL_CALL(DrawElements(glPrimType, indexCount, GR_GL_UNSIGNED_SHORT,
                             this->offsetForBaseIndex(baseIndex)));
    }
    fGpu->didDrawTo(fRenderTarget);
}

onDrawIndexedIndirect()

void GrGLOpsRenderPass::onDrawIndexedIndirect ( const GrBuffer *  drawIndirectBuffer, size_t  offset, int  drawCount  )

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 353 of file GrGLOpsRenderPass.cpp.

                                                             {
    using MultiDrawType = GrGLCaps::MultiDrawType;
 
    SkASSERT(fGpu->caps()->nativeDrawIndirectSupport());
    SkASSERT(!fGpu->caps()->nativeDrawIndexedIndirectIsBroken());
    SkASSERT(fGpu->glCaps().baseVertexBaseInstanceSupport());
    // The vertex buffer should have already gotten bound (as opposed us stashing it away during
    // onBindBuffers and not expecting to bind it until this point).
    SkASSERT(fDidBindVertexBuffer);
 
    if (fGpu->glCaps().multiDrawType() == MultiDrawType::kANGLEOrWebGL) {
        // ANGLE and WebGL don't support glDrawElementsIndirect. We draw everything as a multi draw.
        this->multiDrawElementsANGLEOrWebGL(drawIndirectBuffer, offset, drawCount);
        return;
    }
 
    fGpu->bindBuffer(GrGpuBufferType::kDrawIndirect, drawIndirectBuffer);
 
    if (drawCount > 1 && fGpu->glCaps().multiDrawType() == MultiDrawType::kMultiDrawIndirect) {
        GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
        GL_CALL(MultiDrawElementsIndirect(glPrimType, GR_GL_UNSIGNED_SHORT,
                                          buffer_offset_to_gl_address(drawIndirectBuffer, offset),
                                          drawCount, sizeof(GrDrawIndexedIndirectCommand)));
        return;
    }
 
    for (int i = 0; i < drawCount; ++i) {
        GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
        GL_CALL(DrawElementsIndirect(glPrimType, GR_GL_UNSIGNED_SHORT,
                                     buffer_offset_to_gl_address(drawIndirectBuffer, offset)));
        offset += sizeof(GrDrawIndexedIndirectCommand);
    }
    fGpu->didDrawTo(fRenderTarget);
}

onDrawIndexedInstanced()

void GrGLOpsRenderPass::onDrawIndexedInstanced ( int  indexCount, int  baseIndex, int  instanceCount, int  baseInstance, int  baseVertex  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 244 of file GrGLOpsRenderPass.cpp.

                                                                                 {
    int maxInstances = fGpu->glCaps().maxInstancesPerDrawWithoutCrashing(instanceCount);
    for (int i = 0; i < instanceCount; i += maxInstances) {
        GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
        int instanceCountForDraw = std::min(instanceCount - i, maxInstances);
        int baseInstanceForDraw = baseInstance + i;
        if (fGpu->glCaps().baseVertexBaseInstanceSupport()) {
            SkASSERT(fDidBindInstanceBuffer);
            SkASSERT(fDidBindVertexBuffer);
            GL_CALL(DrawElementsInstancedBaseVertexBaseInstance(
                    glPrimType, indexCount, GR_GL_UNSIGNED_SHORT,
                    this->offsetForBaseIndex(baseIndex), instanceCountForDraw, baseVertex,
                    baseInstanceForDraw));
        } else {
            this->bindInstanceBuffer(fActiveInstanceBuffer.get(), baseInstanceForDraw);
            this->bindVertexBuffer(fActiveVertexBuffer.get(), baseVertex);
            GL_CALL(DrawElementsInstanced(glPrimType, indexCount, GR_GL_UNSIGNED_SHORT,
                                        this->offsetForBaseIndex(baseIndex), instanceCountForDraw));
        }
    }
    fGpu->didDrawTo(fRenderTarget);
}

onDrawIndirect()

void GrGLOpsRenderPass::onDrawIndirect ( const GrBuffer *  drawIndirectBuffer, size_t  offset, int  drawCount  )

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 276 of file GrGLOpsRenderPass.cpp.

                                                      {
    using MultiDrawType = GrGLCaps::MultiDrawType;
 
    SkASSERT(fGpu->caps()->nativeDrawIndirectSupport());
    SkASSERT(fGpu->glCaps().baseVertexBaseInstanceSupport());
    SkASSERT(fDidBindVertexBuffer || fGpu->glCaps().drawArraysBaseVertexIsBroken());
 
    if (fGpu->glCaps().drawArraysBaseVertexIsBroken()) {
        // We weren't able to bind the vertex buffer during onBindBuffers because of a driver bug
        // affecting glDrawArrays.
        this->bindVertexBuffer(fActiveVertexBuffer.get(), 0);
    }
 
    if (fGpu->glCaps().multiDrawType() == MultiDrawType::kANGLEOrWebGL) {
        // ANGLE and WebGL don't support glDrawElementsIndirect. We draw everything as a multi draw.
        this->multiDrawArraysANGLEOrWebGL(drawIndirectBuffer, offset, drawCount);
        return;
    }
 
    fGpu->bindBuffer(GrGpuBufferType::kDrawIndirect, drawIndirectBuffer);
 
    if (drawCount > 1 && fGpu->glCaps().multiDrawType() == MultiDrawType::kMultiDrawIndirect) {
        GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
        GL_CALL(MultiDrawArraysIndirect(glPrimType,
                                        buffer_offset_to_gl_address(drawIndirectBuffer, offset),
                                        drawCount, sizeof(GrDrawIndirectCommand)));
        return;
    }
 
    for (int i = 0; i < drawCount; ++i) {
        GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
        GL_CALL(DrawArraysIndirect(glPrimType,
                                   buffer_offset_to_gl_address(drawIndirectBuffer, offset)));
        offset += sizeof(GrDrawIndirectCommand);
    }
    fGpu->didDrawTo(fRenderTarget);
}

onDrawInstanced()

void GrGLOpsRenderPass::onDrawInstanced ( int  instanceCount, int  baseInstance, int  vertexCount, int  baseVertex  )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 219 of file GrGLOpsRenderPass.cpp.

                                                        {
    SkASSERT(fDidBindVertexBuffer || fGpu->glCaps().drawArraysBaseVertexIsBroken());
    if (fGpu->glCaps().drawArraysBaseVertexIsBroken()) {
        // We weren't able to bind the vertex buffer during onBindBuffers because of a driver bug
        // affecting glDrawArrays.
        this->bindVertexBuffer(fActiveVertexBuffer.get(), 0);
    }
    int maxInstances = fGpu->glCaps().maxInstancesPerDrawWithoutCrashing(instanceCount);
    for (int i = 0; i < instanceCount; i += maxInstances) {
        GrGLenum glPrimType = fGpu->prepareToDraw(fPrimitiveType);
        int instanceCountForDraw = std::min(instanceCount - i, maxInstances);
        int baseInstanceForDraw = baseInstance + i;
        if (fGpu->glCaps().baseVertexBaseInstanceSupport()) {
            SkASSERT(fDidBindInstanceBuffer);
            GL_CALL(DrawArraysInstancedBaseInstance(glPrimType, baseVertex, vertexCount,
                                                    instanceCountForDraw, baseInstanceForDraw));
        } else {
            this->bindInstanceBuffer(fActiveInstanceBuffer.get(), baseInstanceForDraw);
            GL_CALL(DrawArraysInstanced(glPrimType, baseVertex, vertexCount, instanceCountForDraw));
        }
    }
    fGpu->didDrawTo(fRenderTarget);
}

onEnd()

void GrGLOpsRenderPass::onEnd ( )

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 66 of file GrGLOpsRenderPass.cpp.

                              {
    auto glRT = static_cast<GrGLRenderTarget*>(fRenderTarget);
    fGpu->endCommandBuffer(glRT, fUseMultisampleFBO, fColorLoadAndStoreInfo,
                           fStencilLoadAndStoreInfo);
 
    if (fUseMultisampleFBO &&
        fColorLoadAndStoreInfo.fStoreOp == GrStoreOp::kStore &&
        glRT->hasDynamicMSAAAttachment()) {
        // Blit the msaa attachment into the single sample fbo.
        fGpu->resolveRenderFBOs(glRT, this->dmsaaLoadStoreBounds().asSkIRect(),
                                GrGLGpu::ResolveDirection::kMSAAToSingle,
                                true /*invalidateReadBufferAfterBlit*/);
    }
}

onSetScissorRect()

void GrGLOpsRenderPass::onSetScissorRect ( const SkIRect &  scissor )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 87 of file GrGLOpsRenderPass.cpp.

                                                               {
    fGpu->flushScissorRect(scissor, fRenderTarget->height(), fOrigin);
}

reset()

void GrGLOpsRenderPass::reset ( )

inline

Definition at line 36 of file GrGLOpsRenderPass.h.

                 {
        fRenderTarget = nullptr;
    }

set()

void GrGLOpsRenderPass::set	(	GrRenderTarget *	rt,
		bool	useMSAASurface,
		const SkIRect &	contentBounds,
		GrSurfaceOrigin	origin,
		const LoadAndStoreInfo &	colorInfo,
		const StencilLoadAndStoreInfo &	stencilInfo
	)

Definition at line 21 of file GrGLOpsRenderPass.cpp.

                                                                        {
    SkASSERT(fGpu);
    SkASSERT(!fRenderTarget);
    SkASSERT(fGpu == rt->getContext()->priv().getGpu());
 
    this->INHERITED::set(rt, origin);
    fUseMultisampleFBO = useMSAASurface;
    fContentBounds = contentBounds;
    fColorLoadAndStoreInfo = colorInfo;
    fStencilLoadAndStoreInfo = stencilInfo;
}

---

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

• third_party/skia/src/gpu/ganesh/gl/GrGLOpsRenderPass.h
• third_party/skia/src/gpu/ganesh/gl/GrGLOpsRenderPass.cpp