#include <GrGLGpu.h>

Inheritance diagram for GrGLGpu:

Classes
class	SamplerObjectCache

Public Types
using	ResolveDirection = GrGLRenderTarget::ResolveDirection

Public Types inherited from GrGpu
enum class	DisconnectType { kAbandon , kCleanup }

Public Member Functions
	~GrGLGpu () override

void	disconnect (DisconnectType) override

GrThreadSafePipelineBuilder *	pipelineBuilder () override

sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder () override

const GrGLContext &	glContext () const

const GrGLInterface *	glInterface () const

const GrGLContextInfo &	ctxInfo () const

GrGLStandard	glStandard () const

GrGLVersion	glVersion () const

SkSL::GLSLGeneration	glslGeneration () const

const GrGLCaps &	glCaps () const

GrStagingBufferManager *	stagingBufferManager () override

void	bindTexture (int unitIdx, GrSamplerState samplerState, const skgpu::Swizzle &, GrGLTexture *)

void	bindVertexArray (GrGLuint id)

void	notifyVertexArrayDelete (GrGLuint id)

GrGLenum	bindBuffer (GrGpuBufferType type, const GrBuffer *)

bool	flushGLState (GrRenderTarget *, bool useMultisampleFBO, const GrProgramInfo &)

void	flushScissorRect (const SkIRect &scissor, int rtHeight, GrSurfaceOrigin)

void	flushViewport (const SkIRect &viewport, int rtHeight, GrSurfaceOrigin)

GrGLProgram *	currentProgram ()

GrGLAttribArrayState *	bindInternalVertexArray (const GrBuffer *indexBuffer, int numAttribs, GrPrimitiveRestart primitiveRestart)

GrGLenum	prepareToDraw (GrPrimitiveType primitiveType)

void	resolveRenderFBOs (GrGLRenderTarget *, const SkIRect &resolveRect, ResolveDirection, bool invalidateReadBufferAfterBlit=false)

void	drawSingleIntoMSAAFBO (GrGLRenderTarget *rt, const SkIRect &drawBounds)

void	clear (const GrScissorState &, std::array< float, 4 > color, GrRenderTarget *, bool useMultisampleFBO, GrSurfaceOrigin)

void	clearStencilClip (const GrScissorState &, bool insideStencilMask, GrRenderTarget *, bool useMultisampleFBO, GrSurfaceOrigin)

void	beginCommandBuffer (GrGLRenderTarget *, bool useMultisampleFBO, const SkIRect &bounds, GrSurfaceOrigin, const GrOpsRenderPass::LoadAndStoreInfo &colorLoadStore, const GrOpsRenderPass::StencilLoadAndStoreInfo &stencilLoadStore)

void	endCommandBuffer (GrGLRenderTarget *, bool useMultisampleFBO, const GrOpsRenderPass::LoadAndStoreInfo &colorLoadStore, const GrOpsRenderPass::StencilLoadAndStoreInfo &stencilLoadStore)

void	invalidateBoundRenderTarget ()

sk_sp< GrAttachment >	makeStencilAttachment (const GrBackendFormat &colorFormat, SkISize dimensions, int numStencilSamples) override

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

void	deleteBackendTexture (const GrBackendTexture &) override

bool	compile (const GrProgramDesc &, const GrProgramInfo &) override

bool	precompileShader (const SkData &key, const SkData &data) override

void	willExecute () override

void	submit (GrOpsRenderPass *renderPass) override

GrGLsync	insertFence ()

bool	waitFence (GrGLsync)

void	deleteFence (GrGLsync)

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

void	checkFinishProcs () override

void	finishOutstandingGpuWork () override

void	clearErrorsAndCheckForOOM ()

GrGLenum	getErrorAndCheckForOOM ()

std::unique_ptr< GrSemaphore >	prepareTextureForCrossContextUsage (GrTexture *) override

void	deleteSync (GrGLsync)

void	bindFramebuffer (GrGLenum fboTarget, GrGLuint fboid)

void	deleteFramebuffer (GrGLuint fboid)

void	flushProgram (sk_sp< GrGLProgram >)

void	flushProgram (GrGLuint)

void	didDrawTo (GrRenderTarget *)

Public Member Functions inherited from GrGpu
	GrGpu (GrDirectContext *direct)

virtual	~GrGpu ()

GrDirectContext *	getContext ()

const GrDirectContext *	getContext () const

const GrCaps *	caps () const

sk_sp< const GrCaps >	refCaps () const

virtual GrStagingBufferManager *	stagingBufferManager ()

virtual GrRingBuffer *	uniformsRingBuffer ()

virtual void	disconnect (DisconnectType)

virtual GrThreadSafePipelineBuilder *	pipelineBuilder ()=0

virtual sk_sp< GrThreadSafePipelineBuilder >	refPipelineBuilder ()=0

virtual bool	isDeviceLost () const

void	markContextDirty (uint32_t state=kAll_GrBackendState)

sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Budgeted budgeted, GrProtected isProtected, GrColorType textureColorType, GrColorType srcColorType, const GrMipLevel texels[], int texelLevelCount, std::string_view label)

sk_sp< GrTexture >	createTexture (SkISize dimensions, const GrBackendFormat &format, GrTextureType textureType, GrRenderable renderable, int renderTargetSampleCnt, skgpu::Mipmapped mipmapped, skgpu::Budgeted budgeted, GrProtected isProtected, std::string_view label)

sk_sp< GrTexture >	createCompressedTexture (SkISize dimensions, const GrBackendFormat &format, skgpu::Budgeted budgeted, skgpu::Mipmapped mipmapped, GrProtected isProtected, const void *data, size_t dataSize)

sk_sp< GrTexture >	wrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType)

sk_sp< GrTexture >	wrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable)

sk_sp< GrTexture >	wrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable)

sk_sp< GrRenderTarget >	wrapBackendRenderTarget (const GrBackendRenderTarget &)

sk_sp< GrRenderTarget >	wrapVulkanSecondaryCBAsRenderTarget (const SkImageInfo &, const GrVkDrawableInfo &)

sk_sp< GrGpuBuffer >	createBuffer (size_t size, GrGpuBufferType intendedType, GrAccessPattern accessPattern)

void	resolveRenderTarget (GrRenderTarget *, const SkIRect &resolveRect)

bool	regenerateMipMapLevels (GrTexture *)

void	resetTextureBindings ()

bool	readPixels (GrSurface surface, SkIRect rect, GrColorType surfaceColorType, GrColorType dstColorType, void buffer, size_t rowBytes)

bool	writePixels (GrSurface *surface, SkIRect rect, GrColorType surfaceColorType, GrColorType srcColorType, const GrMipLevel texels[], int mipLevelCount, bool prepForTexSampling=false)

bool	writePixels (GrSurface surface, SkIRect rect, GrColorType surfaceColorType, GrColorType srcColorType, const void buffer, size_t rowBytes, bool prepForTexSampling=false)

bool	transferFromBufferToBuffer (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size)

bool	transferPixelsTo (GrTexture *texture, SkIRect rect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer > transferBuffer, size_t offset, size_t rowBytes)

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

bool	copySurface (GrSurface dst, const SkIRect &dstRect, GrSurface src, const SkIRect &srcRect, GrSamplerState::Filter filter)

GrOpsRenderPass *	getOpsRenderPass (GrRenderTarget renderTarget, bool useMSAASurface, GrAttachment stencil, GrSurfaceOrigin, const SkIRect &bounds, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const skia_private::TArray< GrSurfaceProxy *, true > &sampledProxies, GrXferBarrierFlags renderPassXferBarriers)

void	executeFlushInfo (SkSpan< GrSurfaceProxy * >, SkSurfaces::BackendSurfaceAccess access, const GrFlushInfo &, const skgpu::MutableTextureState *newState)

virtual void	willExecute ()

bool	submitToGpu (GrSyncCpu sync)

virtual void	submit (GrOpsRenderPass *)=0

virtual std::unique_ptr< GrSemaphore >	makeSemaphore (bool isOwned=true)=0

virtual std::unique_ptr< GrSemaphore >	wrapBackendSemaphore (const GrBackendSemaphore &, GrSemaphoreWrapType, GrWrapOwnership)=0

virtual void	insertSemaphore (GrSemaphore *semaphore)=0

virtual void	waitSemaphore (GrSemaphore *semaphore)=0

virtual void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext)=0

virtual void	checkFinishProcs ()=0

virtual void	finishOutstandingGpuWork ()=0

virtual void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >)

bool	checkAndResetOOMed ()

virtual std::unique_ptr< GrSemaphore >	prepareTextureForCrossContextUsage (GrTexture *)=0

virtual void	releaseUnlockedBackendObjects ()

Stats *	stats ()

void	dumpJSON (SkJSONWriter *) const

GrBackendTexture	createBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label)

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

GrBackendTexture	createCompressedBackendTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, GrProtected)

bool	updateCompressedBackendTexture (const GrBackendTexture &, sk_sp< skgpu::RefCntedCallback > finishedCallback, const void *data, size_t length)

virtual bool	setBackendTextureState (const GrBackendTexture &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState, sk_sp< skgpu::RefCntedCallback > finishedCallback)

virtual bool	setBackendRenderTargetState (const GrBackendRenderTarget &, const skgpu::MutableTextureState &, skgpu::MutableTextureState *previousState, sk_sp< skgpu::RefCntedCallback > finishedCallback)

virtual void	deleteBackendTexture (const GrBackendTexture &)=0

virtual bool	compile (const GrProgramDesc &, const GrProgramInfo &)=0

virtual bool	precompileShader (const SkData &key, const SkData &data)

virtual sk_sp< GrAttachment >	makeStencilAttachment (const GrBackendFormat &colorFormat, SkISize dimensions, int numStencilSamples)=0

virtual GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &)=0

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

void	handleDirtyContext ()

virtual void	storeVkPipelineCacheData ()

virtual void	xferBarrier (GrRenderTarget *, GrXferBarrierType)=0

Static Public Member Functions
static std::unique_ptr< GrGpu >	Make (sk_sp< const GrGLInterface >, const GrContextOptions &, GrDirectContext *)

Additional Inherited Members
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 89 of file GrGLGpu.h.

Member Typedef Documentation

◆ ResolveDirection

using GrGLGpu::ResolveDirection = GrGLRenderTarget::ResolveDirection

Definition at line 166 of file GrGLGpu.h.

Constructor & Destructor Documentation

◆ ~GrGLGpu()

GrGLGpu::~GrGLGpu ( )

override

Definition at line 473 of file GrGLGpu.cpp.

                  {
    // Ensure any GrGpuResource objects get deleted first, since they may require a working GrGLGpu
    // to release the resources held by the objects themselves.
    fCopyProgramArrayBuffer.reset();
    fMipmapProgramArrayBuffer.reset();
    if (fProgramCache) {
        fProgramCache->reset();
    }
 
    fHWProgram.reset();
    if (fHWProgramID) {
        // detach the current program so there is no confusion on OpenGL's part
        // that we want it to be deleted
        GL_CALL(UseProgram(0));
    }
 
    if (fTempSrcFBOID) {
        this->deleteFramebuffer(fTempSrcFBOID);
    }
    if (fTempDstFBOID) {
        this->deleteFramebuffer(fTempDstFBOID);
    }
    if (fStencilClearFBOID) {
        this->deleteFramebuffer(fStencilClearFBOID);
    }
 
    for (size_t i = 0; i < std::size(fCopyPrograms); ++i) {
        if (0 != fCopyPrograms[i].fProgram) {
            GL_CALL(DeleteProgram(fCopyPrograms[i].fProgram));
        }
    }
 
    for (size_t i = 0; i < std::size(fMipmapPrograms); ++i) {
        if (0 != fMipmapPrograms[i].fProgram) {
            GL_CALL(DeleteProgram(fMipmapPrograms[i].fProgram));
        }
    }
 
    fSamplerObjectCache.reset();
 
    fFinishCallbacks.callAll(true);
}

Member Function Documentation

◆ beginCommandBuffer()

void GrGLGpu::beginCommandBuffer	(	GrGLRenderTarget *	rt,
		bool	useMultisampleFBO,
		const SkIRect &	bounds,
		GrSurfaceOrigin	origin,
		const GrOpsRenderPass::LoadAndStoreInfo &	colorLoadStore,
		const GrOpsRenderPass::StencilLoadAndStoreInfo &	stencilLoadStore
	)

Definition at line 2211 of file GrGLGpu.cpp.

                                                                                                 {
    SkASSERT(!fIsExecutingCommandBuffer_DebugOnly);
 
    this->handleDirtyContext();
 
    this->flushRenderTarget(rt, useMultisampleFBO);
    SkDEBUGCODE(fIsExecutingCommandBuffer_DebugOnly = true);
 
    if (use_tiled_rendering(this->glCaps(), stencilLoadStore)) {
        auto nativeBounds = GrNativeRect::MakeRelativeTo(origin, rt->height(), bounds);
        GrGLbitfield preserveMask = (GrLoadOp::kLoad == colorLoadStore.fLoadOp)
                ? GR_GL_COLOR_BUFFER_BIT0 : GR_GL_NONE;
        SkASSERT(GrLoadOp::kLoad != stencilLoadStore.fLoadOp);  // Handled by use_tiled_rendering().
        GL_CALL(StartTiling(nativeBounds.fX, nativeBounds.fY, nativeBounds.fWidth,
                            nativeBounds.fHeight, preserveMask));
    }
 
    GrGLbitfield clearMask = 0;
    if (GrLoadOp::kClear == colorLoadStore.fLoadOp) {
        SkASSERT(!this->caps()->performColorClearsAsDraws());
        this->flushClearColor(colorLoadStore.fClearColor);
        this->flushColorWrite(true);
        clearMask |= GR_GL_COLOR_BUFFER_BIT;
    }
    if (GrLoadOp::kClear == stencilLoadStore.fLoadOp) {
        SkASSERT(!this->caps()->performStencilClearsAsDraws());
        GL_CALL(StencilMask(0xffffffff));
        GL_CALL(ClearStencil(0));
        clearMask |= GR_GL_STENCIL_BUFFER_BIT;
    }
    if (clearMask) {
        this->flushScissorTest(GrScissorTest::kDisabled);
        this->disableWindowRectangles();
        GL_CALL(Clear(clearMask));
        if (clearMask & GR_GL_COLOR_BUFFER_BIT) {
            this->didWriteToSurface(rt, origin, nullptr);
        }
    }
}

◆ bindBuffer()

GrGLenum GrGLGpu::bindBuffer	(	GrGpuBufferType	type,
		const GrBuffer *	buffer
	)

Definition at line 2154 of file GrGLGpu.cpp.

                                                                         {
    this->handleDirtyContext();
 
    // Index buffer state is tied to the vertex array.
    if (GrGpuBufferType::kIndex == type) {
        this->bindVertexArray(0);
    }
 
    auto* bufferState = this->hwBufferState(type);
    if (buffer->isCpuBuffer()) {
        if (!bufferState->fBufferZeroKnownBound) {
            GL_CALL(BindBuffer(bufferState->fGLTarget, 0));
            bufferState->fBufferZeroKnownBound = true;
            bufferState->fBoundBufferUniqueID.makeInvalid();
        }
    } else if (static_cast<const GrGpuBuffer*>(buffer)->uniqueID() !=
               bufferState->fBoundBufferUniqueID) {
        const GrGLBuffer* glBuffer = static_cast<const GrGLBuffer*>(buffer);
        GL_CALL(BindBuffer(bufferState->fGLTarget, glBuffer->bufferID()));
        bufferState->fBufferZeroKnownBound = false;
        bufferState->fBoundBufferUniqueID = glBuffer->uniqueID();
    }
 
    return bufferState->fGLTarget;
}

◆ bindFramebuffer()

void GrGLGpu::bindFramebuffer	(	GrGLenum	fboTarget,
		GrGLuint	fboid
	)

Definition at line 3195 of file GrGLGpu.cpp.

                                                             {
    GL_CALL(BindFramebuffer(target, fboid));
    if (target == GR_GL_FRAMEBUFFER || target == GR_GL_DRAW_FRAMEBUFFER) {
        fBoundDrawFramebuffer = fboid;
    }
    this->onFBOChanged();
}

◆ bindInternalVertexArray()

GrGLAttribArrayState * GrGLGpu::bindInternalVertexArray	(	const GrBuffer *	indexBuffer,
		int	numAttribs,
		GrPrimitiveRestart	primitiveRestart
	)

inline

Definition at line 156 of file GrGLGpu.h.

                                                                                       {
        auto* attribState = fHWVertexArrayState.bindInternalVertexArray(this, indexBuffer);
        attribState->enableVertexArrays(this, numAttribs, primitiveRestart);
        return attribState;
    }

◆ bindTexture()

void GrGLGpu::bindTexture	(	int	unitIdx,
		GrSamplerState	samplerState,
		const skgpu::Swizzle &	swizzle,
		GrGLTexture *	texture
	)

Definition at line 2826 of file GrGLGpu.cpp.

                                                {
    SkASSERT(texture);
 
#ifdef SK_DEBUG
    if (!this->caps()->npotTextureTileSupport()) {
        if (samplerState.isRepeatedX()) {
            const int w = texture->width();
            SkASSERT(SkIsPow2(w));
        }
        if (samplerState.isRepeatedY()) {
            const int h = texture->height();
            SkASSERT(SkIsPow2(h));
        }
    }
#endif
 
    GrGpuResource::UniqueID textureID = texture->uniqueID();
    GrGLenum target = texture->target();
    if (fHWTextureUnitBindings[unitIdx].boundID(target) != textureID) {
        this->setTextureUnit(unitIdx);
        GL_CALL(BindTexture(target, texture->textureID()));
        fHWTextureUnitBindings[unitIdx].setBoundID(target, textureID);
    }
 
    if (samplerState.mipmapped() == skgpu::Mipmapped::kYes) {
        if (!this->caps()->mipmapSupport() || texture->mipmapped() == skgpu::Mipmapped::kNo) {
            // We should have caught this already.
            SkASSERT(!samplerState.isAniso());
            samplerState = GrSamplerState(samplerState.wrapModeX(),
                                          samplerState.wrapModeY(),
                                          samplerState.filter(),
                                          GrSamplerState::MipmapMode::kNone);
        } else {
            SkASSERT(!texture->mipmapsAreDirty());
        }
    }
 
    auto timestamp = texture->parameters()->resetTimestamp();
    bool setAll = timestamp < fResetTimestampForTextureParameters;
    const GrGLTextureParameters::SamplerOverriddenState* samplerStateToRecord = nullptr;
    GrGLTextureParameters::SamplerOverriddenState newSamplerState;
    if (this->glCaps().useSamplerObjects()) {
        fSamplerObjectCache->bindSampler(unitIdx, samplerState);
        if (this->glCaps().mustSetAnyTexParameterToEnableMipmapping()) {
            if (samplerState.mipmapped() == skgpu::Mipmapped::kYes) {
                GrGLenum minFilter = filter_to_gl_min_filter(samplerState.filter(),
                                                             samplerState.mipmapMode());
                const GrGLTextureParameters::SamplerOverriddenState& oldSamplerState =
                        texture->parameters()->samplerOverriddenState();
                this->setTextureUnit(unitIdx);
                GL_CALL(TexParameteri(target, GR_GL_TEXTURE_MIN_FILTER, minFilter));
                newSamplerState = oldSamplerState;
                newSamplerState.fMinFilter = minFilter;
                samplerStateToRecord = &newSamplerState;
            }
        }
    } else {
        if (fSamplerObjectCache) {
            fSamplerObjectCache->unbindSampler(unitIdx);
        }
        const GrGLTextureParameters::SamplerOverriddenState& oldSamplerState =
                texture->parameters()->samplerOverriddenState();
        samplerStateToRecord = &newSamplerState;
 
        newSamplerState.fMinFilter = filter_to_gl_min_filter(samplerState.filter(),
                                                             samplerState.mipmapMode());
        newSamplerState.fMagFilter = filter_to_gl_mag_filter(samplerState.filter());
 
        newSamplerState.fWrapS = wrap_mode_to_gl_wrap(samplerState.wrapModeX(), this->glCaps());
        newSamplerState.fWrapT = wrap_mode_to_gl_wrap(samplerState.wrapModeY(), this->glCaps());
 
        newSamplerState.fMaxAniso = std::min(static_cast<GrGLfloat>(samplerState.maxAniso()),
                                             this->glCaps().maxTextureMaxAnisotropy());
 
        // These are the OpenGL default values.
        newSamplerState.fMinLOD = -1000.f;
        newSamplerState.fMaxLOD = 1000.f;
 
        if (setAll || newSamplerState.fMagFilter != oldSamplerState.fMagFilter) {
            this->setTextureUnit(unitIdx);
            GL_CALL(TexParameteri(target, GR_GL_TEXTURE_MAG_FILTER, newSamplerState.fMagFilter));
        }
        if (setAll || newSamplerState.fMinFilter != oldSamplerState.fMinFilter) {
            this->setTextureUnit(unitIdx);
            GL_CALL(TexParameteri(target, GR_GL_TEXTURE_MIN_FILTER, newSamplerState.fMinFilter));
        }
        if (this->glCaps().mipmapLodControlSupport()) {
            if (setAll || newSamplerState.fMinLOD != oldSamplerState.fMinLOD) {
                this->setTextureUnit(unitIdx);
                GL_CALL(TexParameterf(target, GR_GL_TEXTURE_MIN_LOD, newSamplerState.fMinLOD));
            }
            if (setAll || newSamplerState.fMaxLOD != oldSamplerState.fMaxLOD) {
                this->setTextureUnit(unitIdx);
                GL_CALL(TexParameterf(target, GR_GL_TEXTURE_MAX_LOD, newSamplerState.fMaxLOD));
            }
        }
        if (setAll || newSamplerState.fWrapS != oldSamplerState.fWrapS) {
            this->setTextureUnit(unitIdx);
            GL_CALL(TexParameteri(target, GR_GL_TEXTURE_WRAP_S, newSamplerState.fWrapS));
        }
        if (setAll || newSamplerState.fWrapT != oldSamplerState.fWrapT) {
            this->setTextureUnit(unitIdx);
            GL_CALL(TexParameteri(target, GR_GL_TEXTURE_WRAP_T, newSamplerState.fWrapT));
        }
        if (this->glCaps().clampToBorderSupport()) {
            // Make sure the border color is transparent black (the default)
            if (setAll || oldSamplerState.fBorderColorInvalid) {
                this->setTextureUnit(unitIdx);
                static const GrGLfloat kTransparentBlack[4] = {0.f, 0.f, 0.f, 0.f};
                GL_CALL(TexParameterfv(target, GR_GL_TEXTURE_BORDER_COLOR, kTransparentBlack));
            }
        }
        if (this->caps()->anisoSupport()) {
            if (setAll || oldSamplerState.fMaxAniso != newSamplerState.fMaxAniso) {
                GL_CALL(TexParameterf(target,
                                      GR_GL_TEXTURE_MAX_ANISOTROPY,
                                      newSamplerState.fMaxAniso));
            }
        }
    }
    GrGLTextureParameters::NonsamplerState newNonsamplerState;
    newNonsamplerState.fBaseMipMapLevel = 0;
    newNonsamplerState.fMaxMipmapLevel = texture->maxMipmapLevel();
    newNonsamplerState.fSwizzleIsRGBA = true;
 
    const GrGLTextureParameters::NonsamplerState& oldNonsamplerState =
            texture->parameters()->nonsamplerState();
    if (this->glCaps().textureSwizzleSupport()) {
        if (setAll || !oldNonsamplerState.fSwizzleIsRGBA) {
            static constexpr GrGLenum kRGBA[4] {
                GR_GL_RED,
                GR_GL_GREEN,
                GR_GL_BLUE,
                GR_GL_ALPHA
            };
            this->setTextureUnit(unitIdx);
            if (GR_IS_GR_GL(this->glStandard())) {
                static_assert(sizeof(kRGBA[0]) == sizeof(GrGLint));
                GL_CALL(TexParameteriv(target, GR_GL_TEXTURE_SWIZZLE_RGBA,
                                       reinterpret_cast<const GrGLint*>(kRGBA)));
            } else if (GR_IS_GR_GL_ES(this->glStandard())) {
                // ES3 added swizzle support but not GL_TEXTURE_SWIZZLE_RGBA.
                GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SWIZZLE_R, kRGBA[0]));
                GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SWIZZLE_G, kRGBA[1]));
                GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SWIZZLE_B, kRGBA[2]));
                GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SWIZZLE_A, kRGBA[3]));
            }
        }
    }
    // These are not supported in ES2 contexts
    if (this->glCaps().mipmapLevelControlSupport() &&
        (texture->textureType() != GrTextureType::kExternal ||
         !this->glCaps().dontSetBaseOrMaxLevelForExternalTextures())) {
        if (newNonsamplerState.fBaseMipMapLevel != oldNonsamplerState.fBaseMipMapLevel) {
            this->setTextureUnit(unitIdx);
            GL_CALL(TexParameteri(target, GR_GL_TEXTURE_BASE_LEVEL,
                                  newNonsamplerState.fBaseMipMapLevel));
        }
        if (newNonsamplerState.fMaxMipmapLevel != oldNonsamplerState.fMaxMipmapLevel) {
            this->setTextureUnit(unitIdx);
            GL_CALL(TexParameteri(target, GR_GL_TEXTURE_MAX_LEVEL,
                                  newNonsamplerState.fMaxMipmapLevel));
        }
    }
    texture->parameters()->set(samplerStateToRecord, newNonsamplerState,
                               fResetTimestampForTextureParameters);
}

◆ bindVertexArray()

void GrGLGpu::bindVertexArray ( GrGLuint id )

inline

Definition at line 117 of file GrGLGpu.h.

                                      {
        fHWVertexArrayState.setVertexArrayID(this, id);
    }

◆ checkFinishProcs()

void GrGLGpu::checkFinishProcs ( )

overridevirtual

Implements GrGpu.

Definition at line 4386 of file GrGLGpu.cpp.

                               {
    fFinishCallbacks.check();
}

◆ clear()

void GrGLGpu::clear	(	const GrScissorState &	scissor,
		std::array< float, 4 >	color,
		GrRenderTarget *	target,
		bool	useMultisampleFBO,
		GrSurfaceOrigin	origin
	)

Definition at line 2180 of file GrGLGpu.cpp.

                                            {
    // parent class should never let us get here with no RT
    SkASSERT(target);
    SkASSERT(!this->caps()->performColorClearsAsDraws());
    SkASSERT(!scissor.enabled() || !this->caps()->performPartialClearsAsDraws());
 
    this->handleDirtyContext();
 
    GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(target);
 
    this->flushRenderTarget(glRT, useMultisampleFBO);
    this->flushScissor(scissor, glRT->height(), origin);
    this->disableWindowRectangles();
    this->flushColorWrite(true);
    this->flushClearColor(color);
    GL_CALL(Clear(GR_GL_COLOR_BUFFER_BIT));
    this->didWriteToSurface(glRT, origin, scissor.enabled() ? &scissor.rect() : nullptr);
}

◆ clearErrorsAndCheckForOOM()

void GrGLGpu::clearErrorsAndCheckForOOM ( )

Definition at line 4394 of file GrGLGpu.cpp.

                                        {
    while (this->getErrorAndCheckForOOM() != GR_GL_NO_ERROR) {}
}

◆ clearStencilClip()

void GrGLGpu::clearStencilClip	(	const GrScissorState &	scissor,
		bool	insideStencilMask,
		GrRenderTarget *	target,
		bool	useMultisampleFBO,
		GrSurfaceOrigin	origin
	)

Definition at line 2302 of file GrGLGpu.cpp.

                                                       {
    SkASSERT(target);
    SkASSERT(!this->caps()->performStencilClearsAsDraws());
    SkASSERT(!scissor.enabled() || !this->caps()->performPartialClearsAsDraws());
    this->handleDirtyContext();
 
    GrAttachment* sb = target->getStencilAttachment(useMultisampleFBO);
    if (!sb) {
        // We should only get here if we marked a proxy as requiring a SB. However,
        // the SB creation could later fail. Likely clipping is going to go awry now.
        return;
    }
 
    GrGLint stencilBitCount =  GrBackendFormatStencilBits(sb->backendFormat());
#if 0
    SkASSERT(stencilBitCount > 0);
    GrGLint clipStencilMask  = (1 << (stencilBitCount - 1));
#else
    // we could just clear the clip bit but when we go through
    // ANGLE a partial stencil mask will cause clears to be
    // turned into draws. Our contract on OpsTask says that
    // changing the clip between stencil passes may or may not
    // zero the client's clip bits. So we just clear the whole thing.
    static const GrGLint clipStencilMask  = ~0;
#endif
    GrGLint value;
    if (insideStencilMask) {
        value = (1 << (stencilBitCount - 1));
    } else {
        value = 0;
    }
    GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(target);
    this->flushRenderTarget(glRT, useMultisampleFBO);
 
    this->flushScissor(scissor, glRT->height(), origin);
    this->disableWindowRectangles();
 
    GL_CALL(StencilMask((uint32_t) clipStencilMask));
    GL_CALL(ClearStencil(value));
    GL_CALL(Clear(GR_GL_STENCIL_BUFFER_BIT));
    fHWStencilSettings.invalidate();
}

◆ compile()

bool GrGLGpu::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 4028 of file GrGLGpu.cpp.

                                                                                 {
    GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
 
    sk_sp<GrGLProgram> tmp = fProgramCache->findOrCreateProgram(this->getContext(),
                                                                desc, programInfo, &stat);
    if (!tmp) {
        return false;
    }
 
    return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
}

◆ ctxInfo()

const GrGLContextInfo & GrGLGpu::ctxInfo ( ) const

inline

Definition at line 104 of file GrGLGpu.h.

104{ return *fGLContext; }

◆ currentProgram()

GrGLProgram * GrGLGpu::currentProgram ( )

inline

Definition at line 144 of file GrGLGpu.h.

                                  {
        this->handleDirtyContext();
        return fHWProgram.get();
    }

◆ deleteBackendTexture()

void GrGLGpu::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 4019 of file GrGLGpu.cpp.

                                                              {
    SkASSERT(GrBackendApi::kOpenGL == tex.backend());
 
    GrGLTextureInfo info;
    if (GrBackendTextures::GetGLTextureInfo(tex, &info)) {
        GL_CALL(DeleteTextures(1, &info.fID));
    }
}

◆ deleteFence()

void GrGLGpu::deleteFence ( GrGLsync fence )

Definition at line 4352 of file GrGLGpu.cpp.

                                        {
    if (this->glCaps().fenceSyncSupport()) {
        this->deleteSync(fence);
    }
}

◆ deleteFramebuffer()

void GrGLGpu::deleteFramebuffer ( GrGLuint fboid )

Definition at line 3203 of file GrGLGpu.cpp.

                                              {
    // We're relying on the GL state shadowing being correct in the workaround code below so we
    // need to handle a dirty context.
    this->handleDirtyContext();
    if (fboid == fBoundDrawFramebuffer &&
        this->caps()->workarounds().unbind_attachments_on_bound_render_fbo_delete) {
        // This workaround only applies to deleting currently bound framebuffers
        // on Adreno 420.  Because this is a somewhat rare case, instead of
        // tracking all the attachments of every framebuffer instead just always
        // unbind all attachments.
        GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, GR_GL_COLOR_ATTACHMENT0,
                                        GR_GL_RENDERBUFFER, 0));
        GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, GR_GL_STENCIL_ATTACHMENT,
                                        GR_GL_RENDERBUFFER, 0));
        GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, GR_GL_DEPTH_ATTACHMENT,
                                        GR_GL_RENDERBUFFER, 0));
    }
 
    GL_CALL(DeleteFramebuffers(1, &fboid));
 
    // Deleting the currently bound framebuffer rebinds to 0.
    if (fboid == fBoundDrawFramebuffer) {
        this->onFBOChanged();
    }
}

◆ deleteSync()

void GrGLGpu::deleteSync ( GrGLsync sync )

Definition at line 4411 of file GrGLGpu.cpp.

                                      {
    if (this->glCaps().fenceType() == GrGLCaps::FenceType::kNVFence) {
        GrGLuint nvFence = SkToUInt(reinterpret_cast<intptr_t>(sync));
        GL_CALL(DeleteFences(1, &nvFence));
    } else {
        GL_CALL(DeleteSync(sync));
    }
}

◆ didDrawTo()

void GrGLGpu::didDrawTo ( GrRenderTarget * rt )

Definition at line 2145 of file GrGLGpu.cpp.

                                          {
    SkASSERT(fHWWriteToColor != kUnknown_TriState);
    if (fHWWriteToColor == kYes_TriState) {
        // The bounds are only used to check for empty and we don't know the bounds. The origin
        // is irrelevant if there are no bounds.
        this->didWriteToSurface(rt, kTopLeft_GrSurfaceOrigin, /*bounds=*/nullptr);
    }
}

◆ disconnect()

void GrGLGpu::disconnect ( DisconnectType type )

overridevirtual

Reimplemented from GrGpu.

Definition at line 516 of file GrGLGpu.cpp.

                                            {
    INHERITED::disconnect(type);
    if (DisconnectType::kCleanup == type) {
        if (fHWProgramID) {
            GL_CALL(UseProgram(0));
        }
        if (fTempSrcFBOID) {
            this->deleteFramebuffer(fTempSrcFBOID);
        }
        if (fTempDstFBOID) {
            this->deleteFramebuffer(fTempDstFBOID);
        }
        if (fStencilClearFBOID) {
            this->deleteFramebuffer(fStencilClearFBOID);
        }
        for (size_t i = 0; i < std::size(fCopyPrograms); ++i) {
            if (fCopyPrograms[i].fProgram) {
                GL_CALL(DeleteProgram(fCopyPrograms[i].fProgram));
            }
        }
        for (size_t i = 0; i < std::size(fMipmapPrograms); ++i) {
            if (fMipmapPrograms[i].fProgram) {
                GL_CALL(DeleteProgram(fMipmapPrograms[i].fProgram));
            }
        }
 
        if (fSamplerObjectCache) {
            fSamplerObjectCache->release();
        }
    } else {
        if (fProgramCache) {
            fProgramCache->abandon();
        }
        if (fSamplerObjectCache) {
            fSamplerObjectCache->abandon();
        }
    }
 
    fHWProgram.reset();
    fProgramCache->reset();
    fProgramCache.reset();
 
    fHWProgramID = 0;
    fTempSrcFBOID = 0;
    fTempDstFBOID = 0;
    fStencilClearFBOID = 0;
    fCopyProgramArrayBuffer.reset();
    for (size_t i = 0; i < std::size(fCopyPrograms); ++i) {
        fCopyPrograms[i].fProgram = 0;
    }
    fMipmapProgramArrayBuffer.reset();
    for (size_t i = 0; i < std::size(fMipmapPrograms); ++i) {
        fMipmapPrograms[i].fProgram = 0;
    }
 
    fFinishCallbacks.callAll(/* doDelete */ DisconnectType::kCleanup == type);
}

◆ drawSingleIntoMSAAFBO()

void GrGLGpu::drawSingleIntoMSAAFBO	(	GrGLRenderTarget *	rt,
		const SkIRect &	drawBounds
	)

inline

Definition at line 179 of file GrGLGpu.h.

                                                                                {
        this->copySurfaceAsDraw(rt, true/*drawToMultisampleFBO*/, rt, drawBounds, drawBounds,
                                GrSamplerState::Filter::kNearest);
    }

◆ endCommandBuffer()

void GrGLGpu::endCommandBuffer	(	GrGLRenderTarget *	rt,
		bool	useMultisampleFBO,
		const GrOpsRenderPass::LoadAndStoreInfo &	colorLoadStore,
		const GrOpsRenderPass::StencilLoadAndStoreInfo &	stencilLoadStore
	)

Definition at line 2254 of file GrGLGpu.cpp.

                                                                                               {
    SkASSERT(fIsExecutingCommandBuffer_DebugOnly);
 
    this->handleDirtyContext();
 
    if (rt->uniqueID() != fHWBoundRenderTargetUniqueID ||
        useMultisampleFBO != fHWBoundFramebufferIsMSAA) {
        // The framebuffer binding changed in the middle of a command buffer. We should have already
        // printed a warning during onFBOChanged.
        return;
    }
 
    if (GrGLCaps::kNone_InvalidateFBType != this->glCaps().invalidateFBType()) {
        STArray<2, GrGLenum> discardAttachments;
        if (GrStoreOp::kDiscard == colorLoadStore.fStoreOp) {
            discardAttachments.push_back(
                    rt->isFBO0(useMultisampleFBO) ? GR_GL_COLOR : GR_GL_COLOR_ATTACHMENT0);
        }
        if (GrStoreOp::kDiscard == stencilLoadStore.fStoreOp) {
            discardAttachments.push_back(
                    rt->isFBO0(useMultisampleFBO) ? GR_GL_STENCIL : GR_GL_STENCIL_ATTACHMENT);
        }
 
        if (!discardAttachments.empty()) {
            if (GrGLCaps::kInvalidate_InvalidateFBType == this->glCaps().invalidateFBType()) {
                GL_CALL(InvalidateFramebuffer(GR_GL_FRAMEBUFFER, discardAttachments.size(),
                                              discardAttachments.begin()));
            } else {
                SkASSERT(GrGLCaps::kDiscard_InvalidateFBType == this->glCaps().invalidateFBType());
                GL_CALL(DiscardFramebuffer(GR_GL_FRAMEBUFFER, discardAttachments.size(),
                                           discardAttachments.begin()));
            }
        }
    }
 
    if (use_tiled_rendering(this->glCaps(), stencilLoadStore)) {
        GrGLbitfield preserveMask = (GrStoreOp::kStore == colorLoadStore.fStoreOp)
                ? GR_GL_COLOR_BUFFER_BIT0 : GR_GL_NONE;
        // Handled by use_tiled_rendering().
        SkASSERT(GrStoreOp::kStore != stencilLoadStore.fStoreOp);
        GL_CALL(EndTiling(preserveMask));
    }
 
    SkDEBUGCODE(fIsExecutingCommandBuffer_DebugOnly = false);
}

◆ finishOutstandingGpuWork()

void GrGLGpu::finishOutstandingGpuWork ( )

overridevirtual

Implements GrGpu.

Definition at line 4390 of file GrGLGpu.cpp.

                                       {
    GL_CALL(Finish());
}

◆ flushGLState()

bool GrGLGpu::flushGLState	(	GrRenderTarget *	renderTarget,
		bool	useMultisampleFBO,
		const GrProgramInfo &	programInfo
	)

Definition at line 2076 of file GrGLGpu.cpp.

                                                             {
    this->handleDirtyContext();
 
    sk_sp<GrGLProgram> program = fProgramCache->findOrCreateProgram(this->getContext(),
                                                                    programInfo);
    if (!program) {
        GrCapsDebugf(this->caps(), "Failed to create program!\n");
        return false;
    }
 
    this->flushProgram(std::move(program));
 
    // Swizzle the blend to match what the shader will output.
    this->flushBlendAndColorWrite(programInfo.pipeline().getXferProcessor().getBlendInfo(),
                                  programInfo.pipeline().writeSwizzle());
 
    fHWProgram->updateUniforms(renderTarget, programInfo);
 
    GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(renderTarget);
    GrStencilSettings stencil;
    if (programInfo.isStencilEnabled()) {
        SkASSERT(glRT->getStencilAttachment(useMultisampleFBO));
        stencil.reset(*programInfo.userStencilSettings(),
                      programInfo.pipeline().hasStencilClip(),
                      glRT->numStencilBits(useMultisampleFBO));
    }
    this->flushStencil(stencil, programInfo.origin());
    this->flushScissorTest(GrScissorTest(programInfo.pipeline().isScissorTestEnabled()));
    this->flushWindowRectangles(programInfo.pipeline().getWindowRectsState(),
                                glRT, programInfo.origin());
    this->flushConservativeRasterState(programInfo.pipeline().usesConservativeRaster());
    this->flushWireframeState(programInfo.pipeline().isWireframe());
 
    // This must come after textures are flushed because a texture may need
    // to be msaa-resolved (which will modify bound FBO state).
    this->flushRenderTarget(glRT, useMultisampleFBO);
 
    return true;
}

◆ flushProgram() [1/2]

void GrGLGpu::flushProgram ( GrGLuint id )

Definition at line 2134 of file GrGLGpu.cpp.

                                      {
    SkASSERT(id);
    if (fHWProgramID == id) {
        SkASSERT(!fHWProgram);
        return;
    }
    fHWProgram.reset();
    GL_CALL(UseProgram(id));
    fHWProgramID = id;
}

◆ flushProgram() [2/2]

void GrGLGpu::flushProgram ( sk_sp< GrGLProgram > program )

Definition at line 2117 of file GrGLGpu.cpp.

                                                     {
    if (!program) {
        fHWProgram.reset();
        fHWProgramID = 0;
        return;
    }
    SkASSERT((program == fHWProgram) == (fHWProgramID == program->programID()));
    if (program == fHWProgram) {
        return;
    }
    auto id = program->programID();
    SkASSERT(id);
    GL_CALL(UseProgram(id));
    fHWProgram = std::move(program);
    fHWProgramID = id;
}

◆ flushScissorRect()

void GrGLGpu::flushScissorRect	(	const SkIRect &	scissor,
		int	rtHeight,
		GrSurfaceOrigin	rtOrigin
	)

Definition at line 2016 of file GrGLGpu.cpp.

                                                                                             {
    SkASSERT(fHWScissorSettings.fEnabled == TriState::kYes_TriState);
    auto nativeScissor = GrNativeRect::MakeRelativeTo(rtOrigin, rtHeight, scissor);
    if (fHWScissorSettings.fRect != nativeScissor) {
        GL_CALL(Scissor(nativeScissor.fX, nativeScissor.fY, nativeScissor.fWidth,
                        nativeScissor.fHeight));
        fHWScissorSettings.fRect = nativeScissor;
    }
}

◆ flushViewport()

void GrGLGpu::flushViewport	(	const SkIRect &	viewport,
		int	rtHeight,
		GrSurfaceOrigin	rtOrigin
	)

Definition at line 2026 of file GrGLGpu.cpp.

                                                                                           {
    auto nativeViewport = GrNativeRect::MakeRelativeTo(rtOrigin, rtHeight, viewport);
    if (fHWViewport != nativeViewport) {
        GL_CALL(Viewport(nativeViewport.fX, nativeViewport.fY,
                         nativeViewport.fWidth, nativeViewport.fHeight));
        fHWViewport = nativeViewport;
    }
}

◆ getErrorAndCheckForOOM()

GrGLenum GrGLGpu::getErrorAndCheckForOOM ( )

Definition at line 4398 of file GrGLGpu.cpp.

                                         {
#if GR_GL_CHECK_ERROR
    if (this->glInterface()->checkAndResetOOMed()) {
        this->setOOMed();
    }
#endif
    GrGLenum error = this->fGLContext->glInterface()->fFunctions.fGetError();
    if (error == GR_GL_OUT_OF_MEMORY) {
        this->setOOMed();
    }
    return error;
}

◆ glCaps()

const GrGLCaps & GrGLGpu::glCaps ( ) const

inline

Definition at line 108 of file GrGLGpu.h.

108{ return *fGLContext->caps(); }

◆ glContext()

const GrGLContext & GrGLGpu::glContext ( ) const

inline

Definition at line 101 of file GrGLGpu.h.

101{ return *fGLContext; }

◆ glInterface()

const GrGLInterface * GrGLGpu::glInterface ( ) const

inline

Definition at line 103 of file GrGLGpu.h.

103{ return fGLContext->glInterface(); }

◆ glslGeneration()

SkSL::GLSLGeneration GrGLGpu::glslGeneration ( ) const

inline

Definition at line 107 of file GrGLGpu.h.

107{ return fGLContext->glslGeneration(); }

◆ glStandard()

GrGLStandard GrGLGpu::glStandard ( ) const

inline

Definition at line 105 of file GrGLGpu.h.

105{ return fGLContext->standard(); }

◆ glVersion()

GrGLVersion GrGLGpu::glVersion ( ) const

inline

Definition at line 106 of file GrGLGpu.h.

106{ return fGLContext->version(); }

◆ insertFence()

GrGLsync GrGLGpu::insertFence ( )

Definition at line 4303 of file GrGLGpu.cpp.

                                            {
    if (!this->glCaps().fenceSyncSupport()) {
        return nullptr;
    }
    GrGLsync sync;
    if (this->glCaps().fenceType() == GrGLCaps::FenceType::kNVFence) {
        static_assert(sizeof(GrGLsync) >= sizeof(GrGLuint));
        GrGLuint fence = 0;
        GL_CALL(GenFences(1, &fence));
        GL_CALL(SetFence(fence, GR_GL_ALL_COMPLETED));
        sync = reinterpret_cast<GrGLsync>(static_cast<intptr_t>(fence));
    } else {
        GL_CALL_RET(sync, FenceSync(GR_GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
    }
    this->setNeedsFlush();
    return sync;
}

◆ insertSemaphore()

void GrGLGpu::insertSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 4369 of file GrGLGpu.cpp.

                                                    {
    SkASSERT(semaphore);
    GrGLSemaphore* glSem = static_cast<GrGLSemaphore*>(semaphore);
 
    GrGLsync sync;
    GL_CALL_RET(sync, FenceSync(GR_GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
    glSem->setSync(sync);
    this->setNeedsFlush();
}

◆ invalidateBoundRenderTarget()

void GrGLGpu::invalidateBoundRenderTarget ( )

inline

Definition at line 205 of file GrGLGpu.h.

                                       {
        fHWBoundRenderTargetUniqueID.makeInvalid();
    }

◆ Make()

std::unique_ptr< GrGpu > GrGLGpu::Make	(	sk_sp< const GrGLInterface >	interface,
		const GrContextOptions &	options,
		GrDirectContext *	direct
	)

static

Definition at line 408 of file GrGLGpu.cpp.

                                                              {
#if !defined(SK_DISABLE_LEGACY_GL_MAKE_NATIVE_INTERFACE)
    if (!interface) {
        interface = GrGLMakeNativeInterface();
        if (!interface) {
            return nullptr;
        }
    }
#else
    if (!interface) {
        return nullptr;
    }
#endif
#ifdef USE_NSIGHT
    const_cast<GrContextOptions&>(options).fSuppressPathRendering = true;
#endif
    auto glContext = GrGLContext::Make(std::move(interface), options);
    if (!glContext) {
        return nullptr;
    }
    return std::unique_ptr<GrGpu>(new GrGLGpu(std::move(glContext), direct));
}

◆ makeMSAAAttachment()

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

overridevirtual

Implements GrGpu.

Definition at line 1986 of file GrGLGpu.cpp.

                                                                           {
    SkASSERT(isMemoryless == GrMemoryless::kNo);
    return GrGLAttachment::MakeMSAA(
            this, dimensions, numSamples, GrBackendFormats::AsGLFormat(format));
}

◆ makeSemaphore()

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

overridevirtual

Implements GrGpu.

Definition at line 4358 of file GrGLGpu.cpp.

                                                                            {
    SkASSERT(this->caps()->semaphoreSupport());
    return GrGLSemaphore::Make(this, isOwned);
}

◆ makeStencilAttachment()

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

overridevirtual

Implements GrGpu.

Definition at line 1971 of file GrGLGpu.cpp.

                                                                                              {
    int sIdx = this->getCompatibleStencilIndex(GrBackendFormats::AsGLFormat(colorFormat));
    if (sIdx < 0) {
        return nullptr;
    }
    GrGLFormat sFmt = this->glCaps().stencilFormats()[sIdx];
 
    auto stencil = GrGLAttachment::MakeStencil(this, dimensions, numStencilSamples, sFmt);
    if (stencil) {
        fStats.incStencilAttachmentCreates();
    }
    return stencil;
}

◆ notifyVertexArrayDelete()

void GrGLGpu::notifyVertexArrayDelete ( GrGLuint id )

inline

Definition at line 123 of file GrGLGpu.h.

                                              {
        fHWVertexArrayState.notifyVertexArrayDelete(id);
    }

◆ pipelineBuilder()

GrThreadSafePipelineBuilder * GrGLGpu::pipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 574 of file GrGLGpu.cpp.

                                                      {
    return fProgramCache.get();
}

◆ precompileShader()

bool GrGLGpu::precompileShader	(	const SkData &	key,
		const SkData &	data
	)

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 222 of file GrGLGpu.h.

                                                                          {
        return fProgramCache->precompileShader(this->getContext(), key, data);
    }

◆ prepareTextureForCrossContextUsage()

std::unique_ptr< GrSemaphore > GrGLGpu::prepareTextureForCrossContextUsage ( GrTexture * )

overridevirtual

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 4420 of file GrGLGpu.cpp.

                                                                                         {
    // Set up a semaphore to be signaled once the data is ready, and flush GL
    std::unique_ptr<GrSemaphore> semaphore = this->makeSemaphore(true);
    SkASSERT(semaphore);
    this->insertSemaphore(semaphore.get());
    // We must call flush here to make sure the GrGLsync object gets created and sent to the gpu.
    this->flush(FlushType::kForce);
 
    return semaphore;
}

◆ prepareToDraw()

GrGLenum GrGLGpu::prepareToDraw ( GrPrimitiveType primitiveType )

Definition at line 2527 of file GrGLGpu.cpp.

                                                             {
    fStats.incNumDraws();
 
    if (this->glCaps().requiresCullFaceEnableDisableWhenDrawingLinesAfterNonLines() &&
        GrIsPrimTypeLines(primitiveType) && !GrIsPrimTypeLines(fLastPrimitiveType)) {
        GL_CALL(Enable(GR_GL_CULL_FACE));
        GL_CALL(Disable(GR_GL_CULL_FACE));
    }
    fLastPrimitiveType = primitiveType;
 
    switch (primitiveType) {
        case GrPrimitiveType::kTriangles:
            return GR_GL_TRIANGLES;
        case GrPrimitiveType::kTriangleStrip:
            return GR_GL_TRIANGLE_STRIP;
        case GrPrimitiveType::kPoints:
            return GR_GL_POINTS;
        case GrPrimitiveType::kLines:
            return GR_GL_LINES;
        case GrPrimitiveType::kLineStrip:
            return GR_GL_LINE_STRIP;
    }
    SK_ABORT("invalid GrPrimitiveType");
}

◆ refPipelineBuilder()

sk_sp< GrThreadSafePipelineBuilder > GrGLGpu::refPipelineBuilder ( )

overridevirtual

Implements GrGpu.

Definition at line 578 of file GrGLGpu.cpp.

                                                               {
    return fProgramCache;
}

◆ resolveRenderFBOs()

void GrGLGpu::resolveRenderFBOs	(	GrGLRenderTarget *	rt,
		const SkIRect &	resolveRect,
		ResolveDirection	resolveDirection,
		bool	invalidateReadBufferAfterBlit = `false`
	)

Definition at line 2562 of file GrGLGpu.cpp.

                                                                    {
    this->handleDirtyContext();
    rt->bindForResolve(resolveDirection);
 
    const GrGLCaps& caps = this->glCaps();
 
    // make sure we go through flushRenderTarget() since we've modified
    // the bound DRAW FBO ID.
    fHWBoundRenderTargetUniqueID.makeInvalid();
    if (GrGLCaps::kES_Apple_MSFBOType == caps.msFBOType()) {
        // The Apple extension doesn't support blitting from single to multisample.
        SkASSERT(resolveDirection != ResolveDirection::kSingleToMSAA);
        SkASSERT(resolveRect == SkIRect::MakeSize(rt->dimensions()));
        // Apple's extension uses the scissor as the blit bounds.
        // Passing in kTopLeft_GrSurfaceOrigin will make sure no transformation of the rect
        // happens inside flushScissor since resolveRect is already in native device coordinates.
        GrScissorState scissor(rt->dimensions());
        SkAssertResult(scissor.set(resolveRect));
        this->flushScissor(scissor, rt->height(), kTopLeft_GrSurfaceOrigin);
        this->disableWindowRectangles();
        GL_CALL(ResolveMultisampleFramebuffer());
    } else {
        SkASSERT(!caps.framebufferResolvesMustBeFullSize() ||
                 resolveRect == SkIRect::MakeSize(rt->dimensions()));
        int l = resolveRect.x();
        int b = resolveRect.y();
        int r = resolveRect.x() + resolveRect.width();
        int t = resolveRect.y() + resolveRect.height();
 
        // BlitFrameBuffer respects the scissor, so disable it.
        this->flushScissorTest(GrScissorTest::kDisabled);
        this->disableWindowRectangles();
        GL_CALL(BlitFramebuffer(l, b, r, t, l, b, r, t, GR_GL_COLOR_BUFFER_BIT, GR_GL_NEAREST));
    }
 
    if (caps.invalidateFBType() != GrGLCaps::kNone_InvalidateFBType &&
        invalidateReadBufferAfterBlit) {
        // Invalidate the read FBO attachment after the blit, in hopes that this allows the driver
        // to perform tiling optimizations.
        bool readBufferIsMSAA = resolveDirection == ResolveDirection::kMSAAToSingle;
        GrGLenum colorDiscardAttachment = rt->isFBO0(readBufferIsMSAA) ? GR_GL_COLOR
                                                                       : GR_GL_COLOR_ATTACHMENT0;
        if (caps.invalidateFBType() == GrGLCaps::kInvalidate_InvalidateFBType) {
            GL_CALL(InvalidateFramebuffer(GR_GL_READ_FRAMEBUFFER, 1, &colorDiscardAttachment));
        } else {
            SkASSERT(caps.invalidateFBType() == GrGLCaps::kDiscard_InvalidateFBType);
            // glDiscardFramebuffer only accepts GL_FRAMEBUFFER.
            rt->bind(readBufferIsMSAA);
            GL_CALL(DiscardFramebuffer(GR_GL_FRAMEBUFFER, 1, &colorDiscardAttachment));
        }
    }
}

◆ stagingBufferManager()

GrStagingBufferManager * GrGLGpu::stagingBufferManager ( )

inlineoverridevirtual

Reimplemented from GrGpu.

Definition at line 110 of file GrGLGpu.h.

110{ return fStagingBufferManager.get(); }

◆ submit()

void GrGLGpu::submit ( GrOpsRenderPass * renderPass )

overridevirtual

Implements GrGpu.

Definition at line 4297 of file GrGLGpu.cpp.

                                                {
    // The GrGLOpsRenderPass doesn't buffer ops so there is nothing to do here
    SkASSERT(fCachedOpsRenderPass.get() == renderPass);
    fCachedOpsRenderPass->reset();
}

◆ waitFence()

bool GrGLGpu::waitFence ( GrGLsync fence )

Definition at line 4345 of file GrGLGpu.cpp.

                                      {
    if (!this->glCaps().fenceSyncSupport()) {
        return true;
    }
    return this->waitSync(fence, 0, false);
}

◆ waitSemaphore()

void GrGLGpu::waitSemaphore ( GrSemaphore * semaphore )

overridevirtual

Implements GrGpu.

Definition at line 4379 of file GrGLGpu.cpp.

                                                  {
    SkASSERT(semaphore);
    GrGLSemaphore* glSem = static_cast<GrGLSemaphore*>(semaphore);
 
    GL_CALL(WaitSync(glSem->sync(), 0, GR_GL_TIMEOUT_IGNORED));
}

◆ willExecute()

void GrGLGpu::willExecute ( )

overridevirtual

Reimplemented from GrGpu.

Definition at line 4289 of file GrGLGpu.cpp.

                          {
    // Because our transfers will be submitted to GL to perfom immediately (no command buffer to
    // submit), we must unmap any staging buffers.
    if (fStagingBufferManager) {
        fStagingBufferManager->detachBuffers();
    }
}

◆ wrapBackendSemaphore()

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

overridevirtual

Implements GrGpu.

Definition at line 4363 of file GrGLGpu.cpp.

                                                                            {
    SK_ABORT("Unsupported");
}

Member Data Documentation

◆ fBoundBufferUniqueID

GrGpuResource::UniqueID GrGLGpu::fBoundBufferUniqueID

Definition at line 743 of file GrGLGpu.h.

◆ fBufferZeroKnownBound

bool GrGLGpu::fBufferZeroKnownBound

Definition at line 744 of file GrGLGpu.h.

◆ fConstColor

SkPMColor4f GrGLGpu::fConstColor

Definition at line 773 of file GrGLGpu.h.

◆ fConstColorValid

bool GrGLGpu::fConstColorValid

Definition at line 774 of file GrGLGpu.h.

◆ fDstCoeff

skgpu::BlendCoeff GrGLGpu::fDstCoeff

Definition at line 772 of file GrGLGpu.h.

◆ fEnabled

TriState GrGLGpu::fEnabled

Definition at line 631 of file GrGLGpu.h.

◆ fEquation

skgpu::BlendEquation GrGLGpu::fEquation

Definition at line 770 of file GrGLGpu.h.

◆ fGLTarget

GrGLenum GrGLGpu::fGLTarget

Definition at line 742 of file GrGLGpu.h.

◆ fPosXformUniform

GrGLint GrGLGpu::fPosXformUniform = 0

Definition at line 829 of file GrGLGpu.h.

◆ fProgram

GrGLuint GrGLGpu::fProgram = 0

Definition at line 826 of file GrGLGpu.h.

◆ fRect

GrNativeRect GrGLGpu::fRect

Definition at line 632 of file GrGLGpu.h.

◆ fSrcCoeff

skgpu::BlendCoeff GrGLGpu::fSrcCoeff

Definition at line 771 of file GrGLGpu.h.

◆ fTexCoordXformUniform

GrGLint GrGLGpu::fTexCoordXformUniform = 0

Definition at line 828 of file GrGLGpu.h.

◆ fTextureUniform

GrGLint GrGLGpu::fTextureUniform = 0

Definition at line 827 of file GrGLGpu.h.

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

third_party/skia/src/gpu/ganesh/gl/GrGLGpu.h
third_party/skia/src/gpu/ganesh/gl/GrGLGpu.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ResolveDirection

Constructor & Destructor Documentation

◆ ~GrGLGpu()

Member Function Documentation

◆ beginCommandBuffer()

◆ bindBuffer()

◆ bindFramebuffer()

◆ bindInternalVertexArray()

◆ bindTexture()

◆ bindVertexArray()

◆ checkFinishProcs()

◆ clear()

◆ clearErrorsAndCheckForOOM()

◆ clearStencilClip()

◆ compile()

◆ ctxInfo()

◆ currentProgram()

◆ deleteBackendTexture()

◆ deleteFence()

◆ deleteFramebuffer()

◆ deleteSync()

◆ didDrawTo()

◆ disconnect()

◆ drawSingleIntoMSAAFBO()

◆ endCommandBuffer()

◆ finishOutstandingGpuWork()

◆ flushGLState()

◆ flushProgram() [1/2]

◆ flushProgram() [2/2]

◆ flushScissorRect()

◆ flushViewport()

◆ getErrorAndCheckForOOM()

◆ glCaps()

◆ glContext()

◆ glInterface()

◆ glslGeneration()

◆ glStandard()

◆ glVersion()

◆ insertFence()

◆ insertSemaphore()

◆ invalidateBoundRenderTarget()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ notifyVertexArrayDelete()

◆ pipelineBuilder()

◆ precompileShader()

◆ prepareTextureForCrossContextUsage()

◆ prepareToDraw()

◆ refPipelineBuilder()

◆ resolveRenderFBOs()

◆ stagingBufferManager()

◆ submit()

◆ waitFence()

◆ waitSemaphore()

◆ willExecute()

◆ wrapBackendSemaphore()

Member Data Documentation

◆ fBoundBufferUniqueID

◆ fBufferZeroKnownBound

◆ fConstColor

◆ fConstColorValid

◆ fDstCoeff

◆ fEnabled

◆ fEquation

◆ fGLTarget

◆ fPosXformUniform

◆ fProgram

◆ fRect

◆ fSrcCoeff

◆ fTexCoordXformUniform

◆ fTextureUniform