#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 GrRingBuffer *	uniformsRingBuffer ()

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)

bool	submitToGpu (GrSyncCpu sync)

virtual void	takeOwnershipOfBuffer (sk_sp< GrGpuBuffer >)

bool	checkAndResetOOMed ()

virtual void	releaseUnlockedBackendObjects ()

Stats *	stats ()

void	dumpJSON (SkJSONWriter *) const

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

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

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

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

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

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

void	handleDirtyContext ()

virtual void	storeVkPipelineCacheData ()

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

Private Member Functions
GrBackendTexture	onCreateBackendTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, skgpu::Mipmapped, GrProtected, std::string_view label) override

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

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

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

void	onResetContext (uint32_t resetBits) override

void	onResetTextureBindings () override

void	xferBarrier (GrRenderTarget *, GrXferBarrierType) override

sk_sp< GrTexture >	onCreateTexture (SkISize dimensions, const GrBackendFormat &, GrRenderable, int renderTargetSampleCnt, skgpu::Budgeted, GrProtected, int mipLevelCount, uint32_t levelClearMask, std::string_view label) override

sk_sp< GrTexture >	onCreateCompressedTexture (SkISize dimensions, const GrBackendFormat &, skgpu::Budgeted, skgpu::Mipmapped, GrProtected, const void *data, size_t dataSize) override

sk_sp< GrGpuBuffer >	onCreateBuffer (size_t size, GrGpuBufferType, GrAccessPattern) override

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

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

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

sk_sp< GrRenderTarget >	onWrapBackendRenderTarget (const GrBackendRenderTarget &) override

GrBackendFormat	getPreferredStencilFormat (const GrBackendFormat &format) override

bool	onReadPixels (GrSurface , SkIRect, GrColorType surfaceColorType, GrColorType dstColorType, void , size_t rowBytes) override

bool	onWritePixels (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType srcColorType, const GrMipLevel[], int mipLevelCount, bool prepForTexSampling) override

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

bool	onTransferPixelsTo (GrTexture *, SkIRect, GrColorType textureColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer >, size_t offset, size_t rowBytes) override

bool	onTransferPixelsFrom (GrSurface *, SkIRect, GrColorType surfaceColorType, GrColorType bufferColorType, sk_sp< GrGpuBuffer >, size_t offset) override

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

bool	onRegenerateMipMapLevels (GrTexture *) override

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

void	addFinishedProc (GrGpuFinishedProc finishedProc, GrGpuFinishedContext finishedContext) override

GrOpsRenderPass *	onGetOpsRenderPass (GrRenderTarget , bool useMultisampleFBO, GrAttachment , GrSurfaceOrigin, const SkIRect &, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const skia_private::TArray< GrSurfaceProxy *, true > &sampledProxies, GrXferBarrierFlags renderPassXferBarriers) override

bool	onSubmitToGpu (GrSyncCpu sync) override

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

◆ addFinishedProc()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 4244 of file GrGLGpu.cpp.

                                                                    {
    fFinishCallbacks.add(finishedProc, finishedContext);
}

◆ beginCommandBuffer()

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

Definition at line 2200 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 2143 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 3184 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 2815 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 4369 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 2169 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 4377 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 2291 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 4012 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 4003 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 4335 of file GrGLGpu.cpp.

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

◆ deleteFramebuffer()

void GrGLGpu::deleteFramebuffer ( GrGLuint fboid )

Definition at line 3192 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 4394 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 2134 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 2243 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 4373 of file GrGLGpu.cpp.

                                       {
    GL_CALL(Finish());
}

◆ flushGLState()

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

Definition at line 2065 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 2123 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 2106 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 2005 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 2015 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 4381 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;
}

◆ getPreferredStencilFormat()

GrBackendFormat GrGLGpu::getPreferredStencilFormat ( const GrBackendFormat & format )

inlineoverrideprivatevirtual

Implements GrGpu.

Definition at line 346 of file GrGLGpu.h.

                                                                                      {
        int idx = this->getCompatibleStencilIndex(GrBackendFormats::AsGLFormat(format));
        if (idx < 0) {
            return {};
        }
        return GrBackendFormats::MakeGL(GrGLFormatToEnum(this->glCaps().stencilFormats()[idx]),
                                        GR_GL_TEXTURE_NONE);
    }

◆ 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 4286 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 4352 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 1975 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 4341 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 1960 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);
    }

◆ onClearBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 3957 of file GrGLGpu.cpp.

                                                              {
    this->handleDirtyContext();
 
    GrGLTextureInfo info;
    SkAssertResult(GrBackendTextures::GetGLTextureInfo(backendTexture, &info));
 
    int numMipLevels = 1;
    if (backendTexture.hasMipmaps()) {
        numMipLevels =
                SkMipmap::ComputeLevelCount(backendTexture.width(), backendTexture.height()) + 1;
    }
 
    GrGLFormat glFormat = GrGLFormatFromGLEnum(info.fFormat);
 
    this->bindTextureToScratchUnit(info.fTarget, info.fID);
 
    // If we have mips make sure the base level is set to 0 and the max level set to numMipLevels-1
    // so that the uploads go to the right levels.
    if (numMipLevels && this->glCaps().mipmapLevelControlSupport()) {
        auto params = get_gl_texture_params(backendTexture);
        GrGLTextureParameters::NonsamplerState nonsamplerState = params->nonsamplerState();
        if (params->nonsamplerState().fBaseMipMapLevel != 0) {
            GL_CALL(TexParameteri(info.fTarget, GR_GL_TEXTURE_BASE_LEVEL, 0));
            nonsamplerState.fBaseMipMapLevel = 0;
        }
        if (params->nonsamplerState().fMaxMipmapLevel != (numMipLevels - 1)) {
            GL_CALL(TexParameteri(info.fTarget, GR_GL_TEXTURE_MAX_LEVEL, numMipLevels - 1));
            nonsamplerState.fBaseMipMapLevel = numMipLevels - 1;
        }
        params->set(nullptr, nonsamplerState, fResetTimestampForTextureParameters);
    }
 
    uint32_t levelMask = (1 << numMipLevels) - 1;
    bool result = this->uploadColorToTex(glFormat,
                                         backendTexture.dimensions(),
                                         info.fTarget,
                                         color,
                                         levelMask);
 
    // Unbind this texture from the scratch texture unit.
    this->bindTextureToScratchUnit(info.fTarget, 0);
    return result;
}

◆ onCopySurface()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 3218 of file GrGLGpu.cpp.

                                                         {
    // Don't prefer copying as a draw if the dst doesn't already have a FBO object.
    // This implicitly handles this->glCaps().useDrawInsteadOfAllRenderTargetWrites().
    bool preferCopy = SkToBool(dst->asRenderTarget());
    bool scalingCopy = dstRect.size() != srcRect.size();
    auto dstFormat = GrBackendFormats::AsGLFormat(dst->backendFormat());
    if (preferCopy &&
        this->glCaps().canCopyAsDraw(dstFormat, SkToBool(src->asTexture()), scalingCopy)) {
        GrRenderTarget* dstRT = dst->asRenderTarget();
        bool drawToMultisampleFBO = dstRT && dstRT->numSamples() > 1;
        if (this->copySurfaceAsDraw(dst, drawToMultisampleFBO, src, srcRect, dstRect, filter)) {
            return true;
        }
    }
 
    // Prefer copying as with glCopyTexSubImage when the dimensions are the same.
    if (!scalingCopy && can_copy_texsubimage(dst, src, this->glCaps())) {
        this->copySurfaceAsCopyTexSubImage(dst, src, srcRect, dstRect.topLeft());
        return true;
    }
 
    if (can_blit_framebuffer_for_copy_surface(dst, src, srcRect, dstRect, this->glCaps())) {
        return this->copySurfaceAsBlitFramebuffer(dst, src, srcRect, dstRect, filter);
    }
 
    if (!preferCopy &&
        this->glCaps().canCopyAsDraw(dstFormat, SkToBool(src->asTexture()), scalingCopy)) {
        GrRenderTarget* dstRT = dst->asRenderTarget();
        bool drawToMultisampleFBO = dstRT && dstRT->numSamples() > 1;
        if (this->copySurfaceAsDraw(dst, drawToMultisampleFBO, src, srcRect, dstRect, filter)) {
            return true;
        }
    }
 
    return false;
}

◆ onCreateBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 3896 of file GrGLGpu.cpp.

                                                                       {
    this->handleDirtyContext();
 
    GrGLFormat glFormat = GrBackendFormats::AsGLFormat(format);
    if (glFormat == GrGLFormat::kUnknown) {
        return {};
    }
 
    int numMipLevels = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
    }
 
    // Compressed formats go through onCreateCompressedBackendTexture
    SkASSERT(!GrGLFormatIsCompressed(glFormat));
 
    GrGLTextureInfo info;
    GrGLTextureParameters::SamplerOverriddenState initialState;
 
    if (glFormat == GrGLFormat::kUnknown) {
        return {};
    }
    switch (format.textureType()) {
        case GrTextureType::kNone:
        case GrTextureType::kExternal:
            return {};
        case GrTextureType::k2D:
            info.fTarget = GR_GL_TEXTURE_2D;
            break;
        case GrTextureType::kRectangle:
            if (!this->glCaps().rectangleTextureSupport() || mipmapped == skgpu::Mipmapped::kYes) {
                return {};
            }
            info.fTarget = GR_GL_TEXTURE_RECTANGLE;
            break;
    }
    info.fFormat = GrGLFormatToEnum(glFormat);
    info.fID = this->createTexture(dimensions, glFormat, info.fTarget, renderable, &initialState,
                                   numMipLevels, isProtected, label);
    if (!info.fID) {
        return {};
    }
    info.fProtected = isProtected;
 
    // Unbind this texture from the scratch texture unit.
    this->bindTextureToScratchUnit(info.fTarget, 0);
 
    auto parameters = sk_make_sp<GrGLTextureParameters>();
    // The non-sampler params are still at their default values.
    parameters->set(&initialState, GrGLTextureParameters::NonsamplerState(),
                    fResetTimestampForTextureParameters);
 
    return GrBackendTextures::MakeGL(
            dimensions.width(), dimensions.height(), mipmapped, info, std::move(parameters), label);
}

◆ onCreateBuffer()

sk_sp< GrGpuBuffer > GrGLGpu::onCreateBuffer	(	size_t	size,
		GrGpuBufferType	intendedType,
		GrAccessPattern	accessPattern
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1985 of file GrGLGpu.cpp.

                                                                          {
    return GrGLBuffer::Make(this, size, intendedType, accessPattern);
}

◆ onCreateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1667 of file GrGLGpu.cpp.

                                                                                    {
    if (isProtected == GrProtected::kYes && !this->glCaps().supportsProtectedContent()) {
        return {};
    }
 
    this->handleDirtyContext();
 
    GrGLFormat glFormat = GrBackendFormats::AsGLFormat(format);
    if (glFormat == GrGLFormat::kUnknown) {
        return {};
    }
 
    SkTextureCompressionType compression = GrBackendFormatToCompressionType(format);
 
    GrGLTextureInfo info;
    GrGLTextureParameters::SamplerOverriddenState initialState;
 
    info.fTarget = GR_GL_TEXTURE_2D;
    info.fFormat = GrGLFormatToEnum(glFormat);
    info.fProtected = isProtected;
    info.fID = this->createCompressedTexture2D(dimensions, compression, glFormat,
                                               mipmapped, info.fProtected, &initialState);
    if (!info.fID) {
        return {};
    }
 
    // Unbind this texture from the scratch texture unit.
    this->bindTextureToScratchUnit(GR_GL_TEXTURE_2D, 0);
 
    auto parameters = sk_make_sp<GrGLTextureParameters>();
    // The non-sampler params are still at their default values.
    parameters->set(&initialState, GrGLTextureParameters::NonsamplerState(),
                    fResetTimestampForTextureParameters);
 
    return GrBackendTextures::MakeGL(
            dimensions.width(), dimensions.height(), mipmapped, info, std::move(parameters));
}

◆ onCreateCompressedTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1619 of file GrGLGpu.cpp.

                                                                     {
    if (isProtected == GrProtected::kYes && !this->glCaps().supportsProtectedContent()) {
        return nullptr;
    }
    SkTextureCompressionType compression = GrBackendFormatToCompressionType(format);
 
    GrGLTextureParameters::SamplerOverriddenState initialState;
    GrGLTexture::Desc desc;
    desc.fSize = dimensions;
    desc.fTarget = GR_GL_TEXTURE_2D;
    desc.fOwnership = GrBackendObjectOwnership::kOwned;
    desc.fFormat = GrBackendFormats::AsGLFormat(format);
    desc.fIsProtected = isProtected;
    desc.fID = this->createCompressedTexture2D(desc.fSize, compression, desc.fFormat,
                                               mipmapped, desc.fIsProtected, &initialState);
    if (!desc.fID) {
        return nullptr;
    }
 
    if (data) {
        if (!this->uploadCompressedTexData(compression, desc.fFormat, dimensions, mipmapped,
                                           GR_GL_TEXTURE_2D, data, dataSize)) {
            GL_CALL(DeleteTextures(1, &desc.fID));
            return nullptr;
        }
    }
 
    // Unbind this texture from the scratch texture unit.
    this->bindTextureToScratchUnit(GR_GL_TEXTURE_2D, 0);
 
    GrMipmapStatus mipmapStatus = mipmapped == skgpu::Mipmapped::kYes
                                          ? GrMipmapStatus::kValid
                                          : GrMipmapStatus::kNotAllocated;
 
    auto tex = sk_make_sp<GrGLTexture>(this, budgeted, desc, mipmapStatus,
                                       /*label=*/"GLGpuCreateCompressedTexture");
    // The non-sampler params are still at their default values.
    tex->parameters()->set(&initialState, GrGLTextureParameters::NonsamplerState(),
                           fResetTimestampForTextureParameters);
    return tex;
}

◆ onCreateTexture()

sk_sp< GrTexture > GrGLGpu::onCreateTexture	(	SkISize	dimensions,
		const GrBackendFormat &	format,
		GrRenderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		int	mipLevelCount,
		uint32_t	levelClearMask,
		std::string_view	label
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 1508 of file GrGLGpu.cpp.

                                                                {
    if (isProtected == GrProtected::kYes && !this->glCaps().supportsProtectedContent()) {
        return nullptr;
    }
    SkASSERT(GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType() || renderTargetSampleCnt == 1);
 
    SkASSERT(mipLevelCount > 0);
    GrMipmapStatus mipmapStatus =
            mipLevelCount > 1 ? GrMipmapStatus::kDirty : GrMipmapStatus::kNotAllocated;
    GrGLTextureParameters::SamplerOverriddenState initialState;
    GrGLTexture::Desc texDesc;
    texDesc.fSize = dimensions;
    switch (format.textureType()) {
        case GrTextureType::kExternal:
        case GrTextureType::kNone:
            return nullptr;
        case GrTextureType::k2D:
            texDesc.fTarget = GR_GL_TEXTURE_2D;
            break;
        case GrTextureType::kRectangle:
            if (mipLevelCount > 1 || !this->glCaps().rectangleTextureSupport()) {
                return nullptr;
            }
            texDesc.fTarget = GR_GL_TEXTURE_RECTANGLE;
            break;
    }
    texDesc.fFormat = GrBackendFormats::AsGLFormat(format);
    texDesc.fOwnership = GrBackendObjectOwnership::kOwned;
    SkASSERT(texDesc.fFormat != GrGLFormat::kUnknown);
    SkASSERT(!GrGLFormatIsCompressed(texDesc.fFormat));
    texDesc.fIsProtected = isProtected;
 
    texDesc.fID = this->createTexture(dimensions, texDesc.fFormat, texDesc.fTarget, renderable,
                                      &initialState, mipLevelCount, texDesc.fIsProtected, label);
    if (!texDesc.fID) {
        return return_null_texture();
    }
 
    sk_sp<GrGLTexture> tex;
    if (renderable == GrRenderable::kYes) {
        // unbind the texture from the texture unit before binding it to the frame buffer
        GL_CALL(BindTexture(texDesc.fTarget, 0));
        GrGLRenderTarget::IDs rtIDDesc;
 
        if (!this->createRenderTargetObjects(texDesc, renderTargetSampleCnt, &rtIDDesc)) {
            GL_CALL(DeleteTextures(1, &texDesc.fID));
            return return_null_texture();
        }
        tex = sk_make_sp<GrGLTextureRenderTarget>(this,
                                                  budgeted,
                                                  renderTargetSampleCnt,
                                                  texDesc,
                                                  rtIDDesc,
                                                  mipmapStatus,
                                                  label);
        tex->baseLevelWasBoundToFBO();
    } else {
        tex = sk_make_sp<GrGLTexture>(this, budgeted, texDesc, mipmapStatus, label);
    }
    // The non-sampler params are still at their default values.
    tex->parameters()->set(&initialState, GrGLTextureParameters::NonsamplerState(),
                           fResetTimestampForTextureParameters);
    if (levelClearMask) {
        if (this->glCaps().clearTextureSupport()) {
            GrGLenum externalFormat, externalType;
            GrColorType colorType;
            this->glCaps().getTexSubImageDefaultFormatTypeAndColorType(
                    texDesc.fFormat, &externalFormat, &externalType, &colorType);
            for (int i = 0; i < mipLevelCount; ++i) {
                if (levelClearMask & (1U << i)) {
                    GL_CALL(ClearTexImage(tex->textureID(), i, externalFormat, externalType,
                                          nullptr));
                }
            }
        } else if (this->glCaps().canFormatBeFBOColorAttachment(
                           GrBackendFormats::AsGLFormat(format)) &&
                   !this->glCaps().performColorClearsAsDraws()) {
            this->flushScissorTest(GrScissorTest::kDisabled);
            this->disableWindowRectangles();
            this->flushColorWrite(true);
            this->flushClearColor({0, 0, 0, 0});
            for (int i = 0; i < mipLevelCount; ++i) {
                if (levelClearMask & (1U << i)) {
                    this->bindSurfaceFBOForPixelOps(tex.get(), i, GR_GL_FRAMEBUFFER,
                                                    kDst_TempFBOTarget);
                    GL_CALL(Clear(GR_GL_COLOR_BUFFER_BIT));
                    this->unbindSurfaceFBOForPixelOps(tex.get(), i, GR_GL_FRAMEBUFFER);
                }
            }
            fHWBoundRenderTargetUniqueID.makeInvalid();
        } else {
            this->bindTextureToScratchUnit(texDesc.fTarget, tex->textureID());
            std::array<float, 4> zeros = {};
            this->uploadColorToTex(texDesc.fFormat,
                                   texDesc.fSize,
                                   texDesc.fTarget,
                                   zeros,
                                   levelClearMask);
        }
    }
    return tex;
}

◆ onGetOpsRenderPass()

GrOpsRenderPass * GrGLGpu::onGetOpsRenderPass	(	GrRenderTarget *	rt,
		bool	useMultisampleFBO,
		GrAttachment *	,
		GrSurfaceOrigin	origin,
		const SkIRect &	bounds,
		const GrOpsRenderPass::LoadAndStoreInfo &	colorInfo,
		const GrOpsRenderPass::StencilLoadAndStoreInfo &	stencilInfo,
		const skia_private::TArray< GrSurfaceProxy *, true > &	sampledProxies,
		GrXferBarrierFlags	renderPassXferBarriers
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 2424 of file GrGLGpu.cpp.

                                                   {
    if (!fCachedOpsRenderPass) {
        fCachedOpsRenderPass = std::make_unique<GrGLOpsRenderPass>(this);
    }
    if (useMultisampleFBO && rt->numSamples() == 1) {
        // We will be using dynamic msaa. Ensure there is an attachment.
        auto glRT = static_cast<GrGLRenderTarget*>(rt);
        if (!glRT->ensureDynamicMSAAAttachment()) {
            SkDebugf("WARNING: Failed to make dmsaa attachment. Render pass will be dropped.");
            return nullptr;
        }
    }
    fCachedOpsRenderPass->set(rt, useMultisampleFBO, bounds, origin, colorInfo, stencilInfo);
    return fCachedOpsRenderPass.get();
}

◆ onReadPixels()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 2396 of file GrGLGpu.cpp.

                                            {
    SkASSERT(surface);
 
    size_t bytesPerPixel = GrColorTypeBytesPerPixel(dstColorType);
 
    // GL_PACK_ROW_LENGTH is in terms of pixels not bytes.
    int rowPixelWidth;
 
    if (rowBytes == SkToSizeT(rect.width()*bytesPerPixel)) {
        rowPixelWidth = rect.width();
    } else {
        SkASSERT(!(rowBytes % bytesPerPixel));
        rowPixelWidth = rowBytes / bytesPerPixel;
    }
    this->unbindXferBuffer(GrGpuBufferType::kXferGpuToCpu);
    return this->readOrTransferPixelsFrom(surface,
                                          rect,
                                          surfaceColorType,
                                          dstColorType,
                                          buffer,
                                          rowPixelWidth);
}

◆ onRegenerateMipMapLevels()

bool GrGLGpu::onRegenerateMipMapLevels ( GrTexture * texture )

overrideprivatevirtual

Implements GrGpu.

Definition at line 3723 of file GrGLGpu.cpp.

                                                         {
    using RegenerateMipmapType = GrGLCaps::RegenerateMipmapType;
 
    auto glTex = static_cast<GrGLTexture*>(texture);
    // Mipmaps are only supported on 2D textures:
    if (GR_GL_TEXTURE_2D != glTex->target()) {
        return false;
    }
    GrGLFormat format = glTex->format();
    // Manual implementation of mipmap generation, to work around driver bugs w/sRGB.
    // Uses draw calls to do a series of downsample operations to successive mips.
 
    // The manual approach requires the ability to limit which level we're sampling and that the
    // destination can be bound to a FBO:
    if (!this->glCaps().doManualMipmapping() || !this->glCaps().isFormatRenderable(format, 1)) {
        GrGLenum target = glTex->target();
        this->bindTextureToScratchUnit(target, glTex->textureID());
        GL_CALL(GenerateMipmap(glTex->target()));
        return true;
    }
 
    int width = texture->width();
    int height = texture->height();
    int levelCount = SkMipmap::ComputeLevelCount(width, height) + 1;
    SkASSERT(levelCount == texture->maxMipmapLevel() + 1);
 
    // Create (if necessary), then bind temporary FBO:
    if (0 == fTempDstFBOID) {
        GL_CALL(GenFramebuffers(1, &fTempDstFBOID));
    }
    this->bindFramebuffer(GR_GL_FRAMEBUFFER, fTempDstFBOID);
    fHWBoundRenderTargetUniqueID.makeInvalid();
 
    // Bind the texture, to get things configured for filtering.
    // We'll be changing our base level and max level further below:
    this->setTextureUnit(0);
    // The mipmap program does not do any swizzling.
    this->bindTexture(0, GrSamplerState::Filter::kLinear, skgpu::Swizzle::RGBA(), glTex);
 
    // Vertex data:
    if (!fMipmapProgramArrayBuffer) {
        static const GrGLfloat vdata[] = {
            0, 0,
            0, 1,
            1, 0,
            1, 1
        };
        fMipmapProgramArrayBuffer = GrGLBuffer::Make(this,
                                                     sizeof(vdata),
                                                     GrGpuBufferType::kVertex,
                                                     kStatic_GrAccessPattern);
        fMipmapProgramArrayBuffer->updateData(vdata, /*offset=*/0,
 
                                              sizeof(vdata),
                                              /*preserve=*/false);
    }
    if (!fMipmapProgramArrayBuffer) {
        return false;
    }
 
    fHWVertexArrayState.setVertexArrayID(this, 0);
 
    GrGLAttribArrayState* attribs = fHWVertexArrayState.bindInternalVertexArray(this);
    attribs->enableVertexArrays(this, 1);
    attribs->set(this, 0, fMipmapProgramArrayBuffer.get(), kFloat2_GrVertexAttribType,
                 SkSLType::kFloat2, 2 * sizeof(GrGLfloat), 0);
 
    // Set "simple" state once:
    this->flushBlendAndColorWrite(skgpu::BlendInfo(), skgpu::Swizzle::RGBA());
    this->flushScissorTest(GrScissorTest::kDisabled);
    this->disableWindowRectangles();
    this->disableStencil();
 
    // Do all the blits:
    width = texture->width();
    height = texture->height();
 
    std::unique_ptr<GrSemaphore> semaphore;
    for (GrGLint level = 1; level < levelCount; ++level) {
        // Get and bind the program for this particular downsample (filter shape can vary):
        int progIdx = TextureSizeToMipmapProgramIdx(width, height);
        if (!fMipmapPrograms[progIdx].fProgram) {
            if (!this->createMipmapProgram(progIdx)) {
                SkDebugf("Failed to create mipmap program.\n");
                // Invalidate all params to cover base and max level change in a previous iteration.
                glTex->textureParamsModified();
                return false;
            }
        }
        this->flushProgram(fMipmapPrograms[progIdx].fProgram);
 
        if (this->glCaps().regenerateMipmapType() == RegenerateMipmapType::kBasePlusSync &&
            level > 1) {
            this->waitSemaphore(semaphore.get());
            semaphore.reset();
        }
 
        // Texcoord uniform is expected to contain (1/w, (w-1)/w, 1/h, (h-1)/h)
        const float invWidth = 1.0f / width;
        const float invHeight = 1.0f / height;
        GL_CALL(Uniform4f(fMipmapPrograms[progIdx].fTexCoordXformUniform,
                          invWidth, (width - 1) * invWidth, invHeight, (height - 1) * invHeight));
        GL_CALL(Uniform1i(fMipmapPrograms[progIdx].fTextureUniform, 0));
 
        // Set the base level so that we only sample from the previous mip.
        SkASSERT(this->glCaps().mipmapLevelControlSupport());
        GL_CALL(TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_BASE_LEVEL, level - 1));
        // Setting the max level is technically unnecessary and can affect
        // validation for the framebuffer. However, by making it clear that a
        // rendering feedback loop is not occurring, we avoid hitting a slow
        // path on some drivers.
        if (this->glCaps().regenerateMipmapType() == RegenerateMipmapType::kBasePlusMaxLevel) {
            GL_CALL(TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MAX_LEVEL, level - 1));
        }
 
        GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER, GR_GL_COLOR_ATTACHMENT0, GR_GL_TEXTURE_2D,
                                     glTex->textureID(), level));
 
        width = std::max(1, width / 2);
        height = std::max(1, height / 2);
        this->flushViewport(SkIRect::MakeWH(width, height), height, kTopLeft_GrSurfaceOrigin);
 
        GL_CALL(DrawArrays(GR_GL_TRIANGLE_STRIP, 0, 4));
 
        if (this->glCaps().regenerateMipmapType() == RegenerateMipmapType::kBasePlusSync &&
            level < levelCount-1) {
            semaphore = this->makeSemaphore(true);
            this->insertSemaphore(semaphore.get());
        }
    }
 
    // Unbind:
    GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER, GR_GL_COLOR_ATTACHMENT0,
                                 GR_GL_TEXTURE_2D, 0, 0));
 
    // We modified the base level and max level params.
    GrGLTextureParameters::NonsamplerState nonsamplerState = glTex->parameters()->nonsamplerState();
    // We drew the 2nd to last level into the last level.
    nonsamplerState.fBaseMipMapLevel = levelCount - 2;
    if (this->glCaps().regenerateMipmapType() == RegenerateMipmapType::kBasePlusMaxLevel) {
        nonsamplerState.fMaxMipmapLevel = levelCount - 2;
    }
    glTex->parameters()->set(nullptr, nonsamplerState, fResetTimestampForTextureParameters);
 
    return true;
}

◆ onResetContext()

void GrGLGpu::onResetContext ( uint32_t resetBits )

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 584 of file GrGLGpu.cpp.

                                               {
    if (resetBits & kMisc_GrGLBackendState) {
        // we don't use the zb at all
        GL_CALL(Disable(GR_GL_DEPTH_TEST));
        GL_CALL(DepthMask(GR_GL_FALSE));
 
        // We don't use face culling.
        GL_CALL(Disable(GR_GL_CULL_FACE));
        // We do use separate stencil. Our algorithms don't care which face is front vs. back so
        // just set this to the default for self-consistency.
        GL_CALL(FrontFace(GR_GL_CCW));
 
        this->hwBufferState(GrGpuBufferType::kXferCpuToGpu)->invalidate();
        this->hwBufferState(GrGpuBufferType::kXferGpuToCpu)->invalidate();
 
        if (GR_IS_GR_GL(this->glStandard())) {
#ifndef USE_NSIGHT
            // Desktop-only state that we never change
            if (!this->glCaps().isCoreProfile()) {
                GL_CALL(Disable(GR_GL_POINT_SMOOTH));
                GL_CALL(Disable(GR_GL_LINE_SMOOTH));
                GL_CALL(Disable(GR_GL_POLYGON_SMOOTH));
                GL_CALL(Disable(GR_GL_POLYGON_STIPPLE));
                GL_CALL(Disable(GR_GL_COLOR_LOGIC_OP));
                GL_CALL(Disable(GR_GL_INDEX_LOGIC_OP));
            }
            // The windows NVIDIA driver has GL_ARB_imaging in the extension string when using a
            // core profile. This seems like a bug since the core spec removes any mention of
            // GL_ARB_imaging.
            if (this->glCaps().imagingSupport() && !this->glCaps().isCoreProfile()) {
                GL_CALL(Disable(GR_GL_COLOR_TABLE));
            }
            GL_CALL(Disable(GR_GL_POLYGON_OFFSET_FILL));
 
            fHWWireframeEnabled = kUnknown_TriState;
#endif
            // Since ES doesn't support glPointSize at all we always use the VS to
            // set the point size
            GL_CALL(Enable(GR_GL_VERTEX_PROGRAM_POINT_SIZE));
 
        }
 
        if (GR_IS_GR_GL_ES(this->glStandard()) &&
            this->glCaps().fbFetchRequiresEnablePerSample()) {
            // The arm extension requires specifically enabling MSAA fetching per sample.
            // On some devices this may have a perf hit.  Also multiple render targets are disabled
            GL_CALL(Enable(GR_GL_FETCH_PER_SAMPLE));
        }
        fHWWriteToColor = kUnknown_TriState;
        // we only ever use lines in hairline mode
        GL_CALL(LineWidth(1));
        GL_CALL(Disable(GR_GL_DITHER));
 
        fHWClearColor[0] = fHWClearColor[1] = fHWClearColor[2] = fHWClearColor[3] = SK_FloatNaN;
    }
 
    if (resetBits & kMSAAEnable_GrGLBackendState) {
        if (this->glCaps().clientCanDisableMultisample()) {
            // Restore GL_MULTISAMPLE to its initial state. It being enabled has no effect on draws
            // to non-MSAA targets.
            GL_CALL(Enable(GR_GL_MULTISAMPLE));
        }
        fHWConservativeRasterEnabled = kUnknown_TriState;
    }
 
    fHWActiveTextureUnitIdx = -1; // invalid
    fLastPrimitiveType = static_cast<GrPrimitiveType>(-1);
 
    if (resetBits & kTextureBinding_GrGLBackendState) {
        for (int s = 0; s < this->numTextureUnits(); ++s) {
            fHWTextureUnitBindings[s].invalidateAllTargets(false);
        }
        if (fSamplerObjectCache) {
            fSamplerObjectCache->invalidateBindings();
        }
    }
 
    if (resetBits & kBlend_GrGLBackendState) {
        fHWBlendState.invalidate();
    }
 
    if (resetBits & kView_GrGLBackendState) {
        fHWScissorSettings.invalidate();
        fHWWindowRectsState.invalidate();
        fHWViewport.invalidate();
    }
 
    if (resetBits & kStencil_GrGLBackendState) {
        fHWStencilSettings.invalidate();
        fHWStencilTestEnabled = kUnknown_TriState;
    }
 
    // Vertex
    if (resetBits & kVertex_GrGLBackendState) {
        fHWVertexArrayState.invalidate();
        this->hwBufferState(GrGpuBufferType::kVertex)->invalidate();
        this->hwBufferState(GrGpuBufferType::kIndex)->invalidate();
        this->hwBufferState(GrGpuBufferType::kDrawIndirect)->invalidate();
    }
 
    if (resetBits & kRenderTarget_GrGLBackendState) {
        fHWBoundRenderTargetUniqueID.makeInvalid();
        fHWSRGBFramebuffer = kUnknown_TriState;
        fBoundDrawFramebuffer = 0;
    }
 
    // we assume these values
    if (resetBits & kPixelStore_GrGLBackendState) {
        if (this->caps()->writePixelsRowBytesSupport() ||
            this->caps()->transferPixelsToRowBytesSupport()) {
            GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
        }
        if (this->glCaps().readPixelsRowBytesSupport()) {
            GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
        }
        if (this->glCaps().packFlipYSupport()) {
            GL_CALL(PixelStorei(GR_GL_PACK_REVERSE_ROW_ORDER, GR_GL_FALSE));
        }
    }
 
    if (resetBits & kProgram_GrGLBackendState) {
        fHWProgramID = 0;
        fHWProgram.reset();
    }
    ++fResetTimestampForTextureParameters;
}

◆ onResetTextureBindings()

void GrGLGpu::onResetTextureBindings ( )

overrideprivatevirtual

Reimplemented from GrGpu.

Definition at line 2984 of file GrGLGpu.cpp.

                                     {
    static constexpr GrGLenum kTargets[] = {GR_GL_TEXTURE_2D, GR_GL_TEXTURE_RECTANGLE,
                                            GR_GL_TEXTURE_EXTERNAL};
    for (int i = 0; i < this->numTextureUnits(); ++i) {
        this->setTextureUnit(i);
        for (auto target : kTargets) {
            if (fHWTextureUnitBindings[i].hasBeenModified(target)) {
                GL_CALL(BindTexture(target, 0));
            }
        }
        fHWTextureUnitBindings[i].invalidateAllTargets(true);
    }
}

◆ onResolveRenderTarget()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 2541 of file GrGLGpu.cpp.

                                                                                      {
    auto glRT = static_cast<GrGLRenderTarget*>(target);
    if (this->glCaps().framebufferResolvesMustBeFullSize()) {
        this->resolveRenderFBOs(glRT, SkIRect::MakeSize(glRT->dimensions()),
                                ResolveDirection::kMSAAToSingle);
    } else {
        this->resolveRenderFBOs(glRT, resolveRect, ResolveDirection::kMSAAToSingle);
    }
}

◆ onSubmitToGpu()

bool GrGLGpu::onSubmitToGpu ( GrSyncCpu sync )

overrideprivatevirtual

Implements GrGpu.

Definition at line 4256 of file GrGLGpu.cpp.

                                          {
    if (sync == GrSyncCpu::kYes ||
        (!fFinishCallbacks.empty() && !this->glCaps().fenceSyncSupport())) {
        this->finishOutstandingGpuWork();
        fFinishCallbacks.callAll(true);
    } else {
        this->flush();
        // See if any previously inserted finish procs are good to go.
        fFinishCallbacks.check();
    }
    if (!this->glCaps().skipErrorChecks()) {
        this->clearErrorsAndCheckForOOM();
    }
    return true;
}

◆ onTransferFromBufferToBuffer()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 988 of file GrGLGpu.cpp.

                                                        {
    SkASSERT(!src->isMapped());
    SkASSERT(!dst->isMapped());
 
    auto glSrc = static_cast<const GrGLBuffer*>(src.get());
    auto glDst = static_cast<const GrGLBuffer*>(dst.get());
 
    // If we refactored bindBuffer() to use something other than GrGpuBufferType to indicate the
    // binding target then we could use the COPY_READ and COPY_WRITE targets here. But
    // CopyBufferSubData is documented to work with all the targets so it's not clear it's worth it.
    this->bindBuffer(GrGpuBufferType::kXferCpuToGpu, glSrc);
    this->bindBuffer(GrGpuBufferType::kXferGpuToCpu, glDst);
 
    GL_CALL(CopyBufferSubData(GR_GL_PIXEL_UNPACK_BUFFER,
                              GR_GL_PIXEL_PACK_BUFFER,
                              srcOffset,
                              dstOffset,
                              size));
    return true;
}

◆ onTransferPixelsFrom()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1082 of file GrGLGpu.cpp.

                                                  {
    auto* glBuffer = static_cast<GrGLBuffer*>(transferBuffer.get());
    SkASSERT(glBuffer->size() >= offset + (rect.width() *
                                           rect.height()*
                                           GrColorTypeBytesPerPixel(dstColorType)));
 
    this->bindBuffer(GrGpuBufferType::kXferGpuToCpu, glBuffer);
 
    auto offsetAsPtr = reinterpret_cast<void*>(offset);
    return this->readOrTransferPixelsFrom(surface,
                                          rect,
                                          surfaceColorType,
                                          dstColorType,
                                          offsetAsPtr,
                                          rect.width());
}

◆ onTransferPixelsTo()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1013 of file GrGLGpu.cpp.

                                                  {
    GrGLTexture* glTex = static_cast<GrGLTexture*>(texture);
 
    // Can't transfer compressed data
    SkASSERT(!GrGLFormatIsCompressed(glTex->format()));
 
    if (!check_write_and_transfer_input(glTex)) {
        return false;
    }
 
    static_assert(sizeof(int) == sizeof(int32_t), "");
 
    this->bindTextureToScratchUnit(glTex->target(), glTex->textureID());
 
    SkASSERT(!transferBuffer->isMapped());
    SkASSERT(!transferBuffer->isCpuBuffer());
    const GrGLBuffer* glBuffer = static_cast<const GrGLBuffer*>(transferBuffer.get());
    this->bindBuffer(GrGpuBufferType::kXferCpuToGpu, glBuffer);
 
    SkASSERT(SkIRect::MakeSize(texture->dimensions()).contains(rect));
 
    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
    const size_t trimRowBytes = rect.width() * bpp;
    const void* pixels = (void*)offset;
 
    SkASSERT(glBuffer->size() >= offset + rowBytes*(rect.height() - 1) + trimRowBytes);
 
    bool restoreGLRowLength = false;
    if (trimRowBytes != rowBytes) {
        // we should have checked for this support already
        SkASSERT(this->glCaps().transferPixelsToRowBytesSupport());
        GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, rowBytes / bpp));
        restoreGLRowLength = true;
    }
 
    GrGLFormat textureFormat = glTex->format();
    // External format and type come from the upload data.
    GrGLenum externalFormat = 0;
    GrGLenum externalType = 0;
    this->glCaps().getTexSubImageExternalFormatAndType(
            textureFormat, textureColorType, bufferColorType, &externalFormat, &externalType);
    if (!externalFormat || !externalType) {
        return false;
    }
 
    GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, 1));
    GL_CALL(TexSubImage2D(glTex->target(),
                          0,
                          rect.left(),
                          rect.top(),
                          rect.width(),
                          rect.height(),
                          externalFormat,
                          externalType,
                          pixels));
 
    if (restoreGLRowLength) {
        GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
    }
 
    return true;
}

◆ onUpdateCompressedBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 1708 of file GrGLGpu.cpp.

                                                              {
    GrGLTextureInfo info;
    SkAssertResult(GrBackendTextures::GetGLTextureInfo(backendTexture, &info));
 
    GrBackendFormat format = backendTexture.getBackendFormat();
    GrGLFormat glFormat = GrBackendFormats::AsGLFormat(format);
    if (glFormat == GrGLFormat::kUnknown) {
        return false;
    }
    SkTextureCompressionType compression = GrBackendFormatToCompressionType(format);
 
    skgpu::Mipmapped mipmapped =
            backendTexture.hasMipmaps() ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
 
    this->bindTextureToScratchUnit(info.fTarget, info.fID);
 
    // If we have mips make sure the base level is set to 0 and the max level set to numMipLevels-1
    // so that the uploads go to the right levels.
    if (backendTexture.hasMipmaps() && this->glCaps().mipmapLevelControlSupport()) {
        auto params = get_gl_texture_params(backendTexture);
        GrGLTextureParameters::NonsamplerState nonsamplerState = params->nonsamplerState();
        if (params->nonsamplerState().fBaseMipMapLevel != 0) {
            GL_CALL(TexParameteri(info.fTarget, GR_GL_TEXTURE_BASE_LEVEL, 0));
            nonsamplerState.fBaseMipMapLevel = 0;
        }
        int numMipLevels =
                SkMipmap::ComputeLevelCount(backendTexture.width(), backendTexture.height()) + 1;
        if (params->nonsamplerState().fMaxMipmapLevel != (numMipLevels - 1)) {
            GL_CALL(TexParameteri(info.fTarget, GR_GL_TEXTURE_MAX_LEVEL, numMipLevels - 1));
            nonsamplerState.fBaseMipMapLevel = numMipLevels - 1;
        }
        params->set(nullptr, nonsamplerState, fResetTimestampForTextureParameters);
    }
 
    bool result = this->uploadCompressedTexData(compression,
                                                glFormat,
                                                backendTexture.dimensions(),
                                                mipmapped,
                                                GR_GL_TEXTURE_2D,
                                                data,
                                                length);
 
    // Unbind this texture from the scratch texture unit.
    this->bindTextureToScratchUnit(info.fTarget, 0);
 
    return result;
}

◆ onWrapBackendRenderTarget()

sk_sp< GrRenderTarget > GrGLGpu::onWrapBackendRenderTarget ( const GrBackendRenderTarget & backendRT )

overrideprivatevirtual

Implements GrGpu.

Definition at line 889 of file GrGLGpu.cpp.

                                                                                               {
    GrGLFramebufferInfo info;
    if (!GrBackendRenderTargets::GetGLFramebufferInfo(backendRT, &info)) {
        return nullptr;
    }
 
    if (backendRT.isProtected() && !this->glCaps().supportsProtectedContent()) {
        return nullptr;
    }
 
    const auto format = GrBackendFormats::AsGLFormat(backendRT.getBackendFormat());
    if (!this->glCaps().isFormatRenderable(format, backendRT.sampleCnt())) {
        return nullptr;
    }
 
    int sampleCount = this->glCaps().getRenderTargetSampleCount(backendRT.sampleCnt(), format);
 
    GrGLRenderTarget::IDs rtIDs;
    if (sampleCount <= 1) {
        rtIDs.fSingleSampleFBOID = info.fFBOID;
        rtIDs.fMultisampleFBOID = GrGLRenderTarget::kUnresolvableFBOID;
    } else {
        rtIDs.fSingleSampleFBOID = GrGLRenderTarget::kUnresolvableFBOID;
        rtIDs.fMultisampleFBOID = info.fFBOID;
    }
    rtIDs.fMSColorRenderbufferID = 0;
    rtIDs.fRTFBOOwnership = GrBackendObjectOwnership::kBorrowed;
    rtIDs.fTotalMemorySamplesPerPixel = sampleCount;
 
    return GrGLRenderTarget::MakeWrapped(this,
                                         backendRT.dimensions(),
                                         format,
                                         sampleCount,
                                         rtIDs,
                                         backendRT.stencilBits(),
                                         skgpu::Protected(backendRT.isProtected()),
                                         /*label=*/"GLGpu_WrapBackendRenderTarget");
}

◆ onWrapBackendTexture()

sk_sp< GrTexture > GrGLGpu::onWrapBackendTexture	(	const GrBackendTexture &	backendTex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable,
		GrIOType	ioType
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 754 of file GrGLGpu.cpp.

                                                                {
    GrGLTexture::Desc desc;
    if (!check_backend_texture(backendTex, this->glCaps(), &desc)) {
        return nullptr;
    }
 
    if (kBorrow_GrWrapOwnership == ownership) {
        desc.fOwnership = GrBackendObjectOwnership::kBorrowed;
    } else {
        desc.fOwnership = GrBackendObjectOwnership::kOwned;
    }
 
    GrMipmapStatus mipmapStatus = backendTex.hasMipmaps() ? GrMipmapStatus::kValid
                                                          : GrMipmapStatus::kNotAllocated;
 
    auto texture = GrGLTexture::MakeWrapped(this,
                                            mipmapStatus,
                                            desc,
                                            get_gl_texture_params(backendTex),
                                            cacheable,
                                            ioType,
                                            backendTex.getLabel());
    if (this->glCaps().isFormatRenderable(backendTex.getBackendFormat(), 1)) {
        // Pessimistically assume this external texture may have been bound to a FBO.
        texture->baseLevelWasBoundToFBO();
    }
    return texture;
}

◆ onWrapCompressedBackendTexture()

sk_sp< GrTexture > GrGLGpu::onWrapCompressedBackendTexture	(	const GrBackendTexture &	backendTex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 814 of file GrGLGpu.cpp.

                                                                                    {
    GrGLTexture::Desc desc;
    if (!check_compressed_backend_texture(backendTex, this->glCaps(), &desc)) {
        return nullptr;
    }
 
    if (kBorrow_GrWrapOwnership == ownership) {
        desc.fOwnership = GrBackendObjectOwnership::kBorrowed;
    } else {
        desc.fOwnership = GrBackendObjectOwnership::kOwned;
    }
 
    GrMipmapStatus mipmapStatus = backendTex.hasMipmaps() ? GrMipmapStatus::kValid
                                                          : GrMipmapStatus::kNotAllocated;
 
    return GrGLTexture::MakeWrapped(this,
                                    mipmapStatus,
                                    desc,
                                    get_gl_texture_params(backendTex),
                                    cacheable,
                                    kRead_GrIOType,
                                    backendTex.getLabel());
}

◆ onWrapRenderableBackendTexture()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 840 of file GrGLGpu.cpp.

                                                                                    {
    const GrGLCaps& caps = this->glCaps();
 
    GrGLTexture::Desc desc;
    if (!check_backend_texture(backendTex, this->glCaps(), &desc)) {
        return nullptr;
    }
    SkASSERT(caps.isFormatRenderable(desc.fFormat, sampleCnt));
    SkASSERT(caps.isFormatTexturable(desc.fFormat));
 
    // We don't support rendering to a EXTERNAL texture.
    if (GR_GL_TEXTURE_EXTERNAL == desc.fTarget) {
        return nullptr;
    }
 
    if (kBorrow_GrWrapOwnership == ownership) {
        desc.fOwnership = GrBackendObjectOwnership::kBorrowed;
    } else {
        desc.fOwnership = GrBackendObjectOwnership::kOwned;
    }
 
 
    sampleCnt = caps.getRenderTargetSampleCount(sampleCnt, desc.fFormat);
    SkASSERT(sampleCnt);
 
    GrGLRenderTarget::IDs rtIDs;
    if (!this->createRenderTargetObjects(desc, sampleCnt, &rtIDs)) {
        return nullptr;
    }
 
    GrMipmapStatus mipmapStatus = backendTex.hasMipmaps() ? GrMipmapStatus::kDirty
                                                          : GrMipmapStatus::kNotAllocated;
 
    sk_sp<GrGLTextureRenderTarget> texRT(
            GrGLTextureRenderTarget::MakeWrapped(this,
                                                 sampleCnt,
                                                 desc,
                                                 get_gl_texture_params(backendTex),
                                                 rtIDs,
                                                 cacheable,
                                                 mipmapStatus,
                                                 backendTex.getLabel()));
    texRT->baseLevelWasBoundToFBO();
    return texRT;
}

◆ onWritePixels()

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

overrideprivatevirtual

Implements GrGpu.

Definition at line 941 of file GrGLGpu.cpp.

                                                     {
    auto glTex = static_cast<GrGLTexture*>(surface->asTexture());
 
    if (!check_write_and_transfer_input(glTex)) {
        return false;
    }
 
    this->bindTextureToScratchUnit(glTex->target(), glTex->textureID());
 
    // If we have mips make sure the base/max levels cover the full range so that the uploads go to
    // the right levels. We've found some Radeons require this.
    if (mipLevelCount && this->glCaps().mipmapLevelControlSupport()) {
        auto params = glTex->parameters();
        GrGLTextureParameters::NonsamplerState nonsamplerState = params->nonsamplerState();
        int maxLevel = glTex->maxMipmapLevel();
        if (params->nonsamplerState().fBaseMipMapLevel != 0) {
            GL_CALL(TexParameteri(glTex->target(), GR_GL_TEXTURE_BASE_LEVEL, 0));
            nonsamplerState.fBaseMipMapLevel = 0;
        }
        if (params->nonsamplerState().fMaxMipmapLevel != maxLevel) {
            GL_CALL(TexParameteri(glTex->target(), GR_GL_TEXTURE_MAX_LEVEL, maxLevel));
            nonsamplerState.fBaseMipMapLevel = maxLevel;
        }
        params->set(nullptr, nonsamplerState, fResetTimestampForTextureParameters);
    }
 
    if (this->glCaps().flushBeforeWritePixels()) {
        GL_CALL(Flush());
    }
 
    SkASSERT(!GrGLFormatIsCompressed(glTex->format()));
    return this->uploadColorTypeTexData(glTex->format(),
                                        surfaceColorType,
                                        glTex->dimensions(),
                                        glTex->target(),
                                        rect,
                                        srcColorType,
                                        texels,
                                        mipLevelCount);
}

◆ 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 4403 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 2516 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 2551 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 4280 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 4328 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 4362 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 4272 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 4346 of file GrGLGpu.cpp.

                                                                            {
    SK_ABORT("Unsupported");
}

◆ xferBarrier()

void GrGLGpu::xferBarrier	(	GrRenderTarget *	rt,
		GrXferBarrierType	type
	)

overrideprivatevirtual

Implements GrGpu.

Definition at line 3870 of file GrGLGpu.cpp.

                                                                    {
    SkASSERT(type);
    switch (type) {
        case kTexture_GrXferBarrierType: {
            GrGLRenderTarget* glrt = static_cast<GrGLRenderTarget*>(rt);
            SkASSERT(glrt->asTexture());
            SkASSERT(!glrt->isFBO0(false/*multisample*/));
            if (glrt->requiresManualMSAAResolve()) {
                // The render target uses separate storage so no need for glTextureBarrier.
                // FIXME: The render target will resolve automatically when its texture is bound,
                // but we could resolve only the bounds that will be read if we do it here instead.
                return;
            }
            SkASSERT(this->caps()->textureBarrierSupport());
            GL_CALL(TextureBarrier());
            return;
        }
        case kBlend_GrXferBarrierType:
            SkASSERT(GrCaps::kAdvanced_BlendEquationSupport ==
                     this->caps()->blendEquationSupport());
            GL_CALL(BlendBarrier());
            return;
        default: break; // placate compiler warnings that kNone not handled
    }
}

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

Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ResolveDirection

Constructor & Destructor Documentation

◆ ~GrGLGpu()

Member Function Documentation

◆ addFinishedProc()

◆ 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()

◆ getPreferredStencilFormat()

◆ glCaps()

◆ glContext()

◆ glInterface()

◆ glslGeneration()

◆ glStandard()

◆ glVersion()

◆ insertFence()

◆ insertSemaphore()

◆ invalidateBoundRenderTarget()

◆ Make()

◆ makeMSAAAttachment()

◆ makeSemaphore()

◆ makeStencilAttachment()

◆ notifyVertexArrayDelete()

◆ onClearBackendTexture()

◆ onCopySurface()

◆ onCreateBackendTexture()

◆ onCreateBuffer()

◆ onCreateCompressedBackendTexture()

◆ onCreateCompressedTexture()

◆ onCreateTexture()

◆ onGetOpsRenderPass()

◆ onReadPixels()

◆ onRegenerateMipMapLevels()

◆ onResetContext()

◆ onResetTextureBindings()

◆ onResolveRenderTarget()

◆ onSubmitToGpu()

◆ onTransferFromBufferToBuffer()

◆ onTransferPixelsFrom()

◆ onTransferPixelsTo()

◆ onUpdateCompressedBackendTexture()

◆ onWrapBackendRenderTarget()

◆ onWrapBackendTexture()

◆ onWrapCompressedBackendTexture()

◆ onWrapRenderableBackendTexture()

◆ onWritePixels()

◆ pipelineBuilder()