GrGLProgram Class Reference

#include <GrGLProgram.h>

Inheritance diagram for GrGLProgram:

Classes
struct	Attribute
struct	RenderTargetState

Public Types
using	UniformHandle = GrGLSLProgramDataManager::UniformHandle
using	UniformInfoArray = GrGLProgramDataManager::UniformInfoArray
using	VaryingInfoArray = GrGLProgramDataManager::VaryingInfoArray

Public Member Functions
	~GrGLProgram () override
void	abandon ()
GrGLuint	programID () const
void	updateUniforms (const GrRenderTarget *, const GrProgramInfo &)
void	bindTextures (const GrGeometryProcessor &, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &)
int	vertexStride () const
int	instanceStride () const
int	numVertexAttributes () const
const Attribute &	vertexAttribute (int i) const
int	numInstanceAttributes () const
const Attribute &	instanceAttribute (int i) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< GrGLProgram >	Make (GrGLGpu *, const GrGLSLBuiltinUniformHandles &, GrGLuint programID, const UniformInfoArray &uniforms, const UniformInfoArray &textureSamplers, std::unique_ptr< GrGeometryProcessor::ProgramImpl >, std::unique_ptr< GrXferProcessor::ProgramImpl >, std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > > fps, std::unique_ptr< Attribute[]>, int vertexAttributeCnt, int instanceAttributeCnt, int vertexStride, int instanceStride)

Detailed Description

This class manages a GPU program and records per-program information. It also records the vertex and instance attribute layouts that are to be used with the program.

Definition at line 31 of file GrGLProgram.h.

Member Typedef Documentation

UniformHandle

using GrGLProgram::UniformHandle = GrGLSLProgramDataManager::UniformHandle

Definition at line 45 of file GrGLProgram.h.

UniformInfoArray

using GrGLProgram::UniformInfoArray = GrGLProgramDataManager::UniformInfoArray

Definition at line 46 of file GrGLProgram.h.

VaryingInfoArray

using GrGLProgram::VaryingInfoArray = GrGLProgramDataManager::VaryingInfoArray

Definition at line 47 of file GrGLProgram.h.

Constructor & Destructor Documentation

~GrGLProgram()

GrGLProgram::~GrGLProgram ( )

override

Definition at line 87 of file GrGLProgram.cpp.

                          {
    if (fProgramID) {
        GL_CALL(DeleteProgram(fProgramID));
    }
}

Member Function Documentation

abandon()

void GrGLProgram::abandon

(

)

Call to abandon GL objects owned by this program.

Definition at line 93 of file GrGLProgram.cpp.

                          {
    fProgramID = 0;
}

bindTextures()

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

Binds all geometry processor and fragment processor textures.

Definition at line 123 of file GrGLProgram.cpp.

                                                           {
    // Bind textures from the geometry processor.
    for (int i = 0; i < geomProc.numTextureSamplers(); ++i) {
        SkASSERT(geomProcTextures[i]->asTextureProxy());
        auto* overrideTexture = static_cast<GrGLTexture*>(geomProcTextures[i]->peekTexture());
        fGpu->bindTexture(i, geomProc.textureSampler(i).samplerState(),
                          geomProc.textureSampler(i).swizzle(), overrideTexture);
    }
    int nextTexSamplerIdx = geomProc.numTextureSamplers();
    // Bind texture from the destination proxy view.
    GrTexture* dstTexture = pipeline.peekDstTexture();
    if (dstTexture) {
        fGpu->bindTexture(nextTexSamplerIdx++, GrSamplerState::Filter::kNearest,
                          pipeline.dstProxyView().swizzle(), static_cast<GrGLTexture*>(dstTexture));
    }
    // Bind textures from all of the fragment processors.
    pipeline.visitTextureEffects([&](const GrTextureEffect& te) {
        GrSamplerState samplerState = te.samplerState();
        skgpu::Swizzle swizzle = te.view().swizzle();
        auto* texture = static_cast<GrGLTexture*>(te.texture());
        fGpu->bindTexture(nextTexSamplerIdx++, samplerState, swizzle, texture);
    });
 
    SkASSERT(nextTexSamplerIdx == fNumTextureSamplers);
}

instanceAttribute()

const Attribute & GrGLProgram::instanceAttribute ( int  i ) const

inline

Definition at line 121 of file GrGLProgram.h.

                                                    {
        SkASSERT(i >= 0 && i < fInstanceAttributeCnt);
        return fAttributes[i + fVertexAttributeCnt];
    }

instanceStride()

int GrGLProgram::instanceStride ( ) const

inline

Definition at line 112 of file GrGLProgram.h.

{ return fInstanceStride; }

Make()

sk_sp< GrGLProgram > GrGLProgram::Make ( GrGLGpu *  gpu, const GrGLSLBuiltinUniformHandles &  builtinUniforms, GrGLuint  programID, const UniformInfoArray &  uniforms, const UniformInfoArray &  textureSamplers, std::unique_ptr< GrGeometryProcessor::ProgramImpl >  gpImpl, std::unique_ptr< GrXferProcessor::ProgramImpl >  xpImpl, std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > >  fps, std::unique_ptr< Attribute[]>  attributes, int  vertexAttributeCnt, int  instanceAttributeCnt, int  vertexStride, int  instanceStride  )

static

The attribute array consists of vertexAttributeCnt + instanceAttributeCnt elements with the vertex attributes preceding the instance attributes.

Definition at line 27 of file GrGLProgram.cpp.

                            {
    sk_sp<GrGLProgram> program(new GrGLProgram(gpu,
                                               builtinUniforms,
                                               programID,
                                               uniforms,
                                               textureSamplers,
                                               std::move(gpImpl),
                                               std::move(xpImpl),
                                               std::move(fpImpls),
                                               std::move(attributes),
                                               vertexAttributeCnt,
                                               instanceAttributeCnt,
                                               vertexStride,
                                               instanceStride));
    // Assign texture units to sampler uniforms one time up front.
    gpu->flushProgram(program);
    program->fProgramDataManager.setSamplerUniforms(textureSamplers, 0);
    return program;
}

numInstanceAttributes()

int GrGLProgram::numInstanceAttributes ( ) const

inline

Definition at line 120 of file GrGLProgram.h.

{ return fInstanceAttributeCnt; }

numVertexAttributes()

int GrGLProgram::numVertexAttributes ( ) const

inline

Definition at line 114 of file GrGLProgram.h.

{ return fVertexAttributeCnt; }

programID()

GrGLuint GrGLProgram::programID ( ) const

inline

Gets the GL program ID for this program.

Definition at line 78 of file GrGLProgram.h.

{ return fProgramID; }

updateUniforms()

void GrGLProgram::updateUniforms	(	const GrRenderTarget *	renderTarget,
		const GrProgramInfo &	programInfo
	)

This function uploads uniforms and calls each GrGLSL*Processor's setData.

It is the caller's responsibility to ensure the program is bound before calling.

Definition at line 99 of file GrGLProgram.cpp.

                                                                   {
    this->setRenderTargetState(renderTarget, programInfo.origin(), programInfo.geomProc());
 
    // we set the uniforms for installed processors in a generic way, but subclasses of GLProgram
    // determine how to set coord transforms
 
    // We must bind to texture units in the same order in which we set the uniforms in
    // GrGLProgramDataManager. That is, we bind textures for processors in this order:
    // primProc, fragProcs, XP.
    fGPImpl->setData(fProgramDataManager, *fGpu->caps()->shaderCaps(), programInfo.geomProc());
 
    for (int i = 0; i < programInfo.pipeline().numFragmentProcessors(); ++i) {
        const auto& fp = programInfo.pipeline().getFragmentProcessor(i);
        fp.visitWithImpls([&](const GrFragmentProcessor& fp,
                              GrFragmentProcessor::ProgramImpl& impl) {
            impl.setData(fProgramDataManager, fp);
        }, *fFPImpls[i]);
    }
 
    programInfo.pipeline().setDstTextureUniforms(fProgramDataManager, &fBuiltinUniformHandles);
    fXPImpl->setData(fProgramDataManager, programInfo.pipeline().getXferProcessor());
}

vertexAttribute()

const Attribute & GrGLProgram::vertexAttribute ( int  i ) const

inline

Definition at line 115 of file GrGLProgram.h.

                                                  {
        SkASSERT(i >= 0 && i < fVertexAttributeCnt);
        return fAttributes[i];
    }

vertexStride()

int GrGLProgram::vertexStride ( ) const

inline

Definition at line 111 of file GrGLProgram.h.

{ return fVertexStride; }

---

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

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