GrQuadEffect::Impl Class Reference

Inheritance diagram for GrQuadEffect::Impl:

Public Member Functions
void	setData (const GrGLSLProgramDataManager &pdman, const GrShaderCaps &shaderCaps, const GrGeometryProcessor &geomProc) override
Public Member Functions inherited from GrGeometryProcessor::ProgramImpl
virtual	~ProgramImpl ()=default
std::tuple< FPCoordsMap, GrShaderVar >	emitCode (EmitArgs &, const GrPipeline &pipeline)
void	emitTransformCode (GrGLSLVertexBuilder *vb, GrGLSLUniformHandler *uniformHandler)

Private Member Functions
void	onEmitCode (EmitArgs &, GrGPArgs *) override

Additional Inherited Members
Public Types inherited from GrGeometryProcessor::ProgramImpl
using	UniformHandle = GrGLSLProgramDataManager::UniformHandle
using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle
using	FPCoordsMap = std::unordered_map< const GrFragmentProcessor *, FPCoords >
Static Public Member Functions inherited from GrGeometryProcessor::ProgramImpl
static uint32_t	ComputeMatrixKey (const GrShaderCaps &caps, const SkMatrix &mat)
static uint32_t	ComputeMatrixKeys (const GrShaderCaps &shaderCaps, const SkMatrix &viewMatrix, const SkMatrix &localMatrix)
static uint32_t	AddMatrixKeys (const GrShaderCaps &shaderCaps, uint32_t flags, const SkMatrix &viewMatrix, const SkMatrix &localMatrix)
Static Public Attributes inherited from GrGeometryProcessor::ProgramImpl
static constexpr int	kMatrixKeyBits = 2
Protected Member Functions inherited from GrGeometryProcessor::ProgramImpl
void	setupUniformColor (GrGLSLFPFragmentBuilder *fragBuilder, GrGLSLUniformHandler *uniformHandler, const char *outputName, UniformHandle *colorUniform)
Static Protected Member Functions inherited from GrGeometryProcessor::ProgramImpl
static void	SetTransform (const GrGLSLProgramDataManager &, const GrShaderCaps &, const UniformHandle &uniform, const SkMatrix &matrix, SkMatrix *state=nullptr)
static void	WriteOutputPosition (GrGLSLVertexBuilder *, GrGPArgs *, const char *posName)
static void	WriteOutputPosition (GrGLSLVertexBuilder *, GrGLSLUniformHandler *, const GrShaderCaps &, GrGPArgs *, const char *posName, const SkMatrix &viewMatrix, UniformHandle *viewMatrixUniform)
static void	WriteLocalCoord (GrGLSLVertexBuilder *, GrGLSLUniformHandler *, const GrShaderCaps &, GrGPArgs *, GrShaderVar localVar, const SkMatrix &localMatrix, UniformHandle *localMatrixUniform)

Detailed Description

Definition at line 212 of file GrBezierEffect.cpp.

Member Function Documentation

onEmitCode()

void GrQuadEffect::Impl::onEmitCode ( EmitArgs &  args, GrGPArgs *  gpArgs  )

overrideprivatevirtual

Implements GrGeometryProcessor::ProgramImpl.

Definition at line 247 of file GrBezierEffect.cpp.

                                                                  {
    GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
    const GrQuadEffect& gp = args.fGeomProc.cast<GrQuadEffect>();
    GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
    GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
    // emit attributes
    varyingHandler->emitAttributes(gp);
 
    GrGLSLVarying v(SkSLType::kHalf4);
    varyingHandler->addVarying("HairQuadEdge", &v);
    vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge().name());
 
    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
    // Setup pass through color
    fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);
    this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform);
 
    // Setup position
    WriteOutputPosition(vertBuilder,
                        uniformHandler,
                        *args.fShaderCaps,
                        gpArgs,
                        gp.inPosition().name(),
                        gp.fViewMatrix,
                        &fViewMatrixUniform);
    if (gp.fUsesLocalCoords) {
        WriteLocalCoord(vertBuilder,
                        uniformHandler,
                        *args.fShaderCaps,
                        gpArgs,
                        gp.inPosition().asShaderVar(),
                        gp.fLocalMatrix,
                        &fLocalMatrixUniform);
    }
 
    fragBuilder->codeAppendf("half edgeAlpha;");
 
    fragBuilder->codeAppendf("half2 duvdx = half2(dFdx(%s.xy));", v.fsIn());
    fragBuilder->codeAppendf("half2 duvdy = half2(dFdy(%s.xy));", v.fsIn());
    fragBuilder->codeAppendf("half2 gF = half2(2.0 * %s.x * duvdx.x - duvdx.y,"
                             "               2.0 * %s.x * duvdy.x - duvdy.y);",
                             v.fsIn(), v.fsIn());
    fragBuilder->codeAppendf("edgeAlpha = half(%s.x * %s.x - %s.y);",
                             v.fsIn(), v.fsIn(), v.fsIn());
    fragBuilder->codeAppend("edgeAlpha = sqrt(edgeAlpha * edgeAlpha / dot(gF, gF));");
    fragBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);");
    // Add line below for smooth cubic ramp
    // fragBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);");
 
    if (gp.fCoverageScale != 0xFF) {
        const char* coverageScale;
        fCoverageScaleUniform = uniformHandler->addUniform(nullptr,
                                                           kFragment_GrShaderFlag,
                                                           SkSLType::kHalf,
                                                           "Coverage",
                                                           &coverageScale);
        fragBuilder->codeAppendf("half4 %s = half4(%s * edgeAlpha);", args.fOutputCoverage,
                                 coverageScale);
    } else {
        fragBuilder->codeAppendf("half4 %s = half4(edgeAlpha);", args.fOutputCoverage);
    }
}

setData()

void GrQuadEffect::Impl::setData ( const GrGLSLProgramDataManager &  , const GrShaderCaps &  , const GrGeometryProcessor &    )

inlineoverridevirtual

A ProgramImpl instance can be reused with any GrGeometryProcessor that produces the same key. This function reads data from a GrGeometryProcessor and updates any uniform variables required by the shaders created in emitCode(). The GrGeometryProcessor parameter is guaranteed to be of the same type and to have an identical processor key as the GrGeometryProcessor that created this ProgramImpl.

Implements GrGeometryProcessor::ProgramImpl.

Definition at line 214 of file GrBezierEffect.cpp.

                                                               {
        const GrQuadEffect& qe = geomProc.cast<GrQuadEffect>();
 
        SetTransform(pdman, shaderCaps,  fViewMatrixUniform,  qe.fViewMatrix, &fViewMatrix);
        SetTransform(pdman, shaderCaps, fLocalMatrixUniform, qe.fLocalMatrix, &fLocalMatrix);
 
        if (qe.fColor != fColor) {
            pdman.set4fv(fColorUniform, 1, qe.fColor.vec());
            fColor = qe.fColor;
        }
 
        if (qe.fCoverageScale != 0xff && qe.fCoverageScale != fCoverageScale) {
            pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(qe.fCoverageScale));
            fCoverageScale = qe.fCoverageScale;
        }
    }

---

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

• third_party/skia/src/gpu/ganesh/effects/GrBezierEffect.cpp