GrConicEffect::Impl Class Reference

Inheritance diagram for GrConicEffect::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 24 of file GrBezierEffect.cpp.

Member Function Documentation

onEmitCode()

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

overrideprivatevirtual

Implements GrGeometryProcessor::ProgramImpl.

Definition at line 59 of file GrBezierEffect.cpp.

                                                                   {
    GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
    const GrConicEffect& gp = args.fGeomProc.cast<GrConicEffect>();
    GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
    GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
    // emit attributes
    varyingHandler->emitAttributes(gp);
 
    GrGLSLVarying v(SkSLType::kFloat4);
    varyingHandler->addVarying("ConicCoeffs", &v);
    vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs().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);
    }
 
    // TODO: we should check on the number of bits float and half provide and use the smallest one
    // that suffices. Additionally we should assert that the upstream code only lets us get here if
    // either float or half provides the required number of bits.
 
    GrShaderVar edgeAlpha("edgeAlpha", SkSLType::kHalf, 0);
    GrShaderVar dklmdx("dklmdx", SkSLType::kFloat3, 0);
    GrShaderVar dklmdy("dklmdy", SkSLType::kFloat3, 0);
    GrShaderVar dfdx("dfdx", SkSLType::kFloat, 0);
    GrShaderVar dfdy("dfdy", SkSLType::kFloat, 0);
    GrShaderVar gF("gF", SkSLType::kFloat2, 0);
    GrShaderVar gFM("gFM", SkSLType::kFloat, 0);
    GrShaderVar func("func", SkSLType::kFloat, 0);
 
    fragBuilder->declAppend(edgeAlpha);
    fragBuilder->declAppend(dklmdx);
    fragBuilder->declAppend(dklmdy);
    fragBuilder->declAppend(dfdx);
    fragBuilder->declAppend(dfdy);
    fragBuilder->declAppend(gF);
    fragBuilder->declAppend(gFM);
    fragBuilder->declAppend(func);
 
    fragBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), v.fsIn());
    fragBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), v.fsIn());
    fragBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;",
                             dfdx.c_str(),
                             v.fsIn(), dklmdx.c_str(),
                             v.fsIn(), dklmdx.c_str(),
                             v.fsIn(), dklmdx.c_str());
    fragBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;",
                             dfdy.c_str(),
                             v.fsIn(), dklmdy.c_str(),
                             v.fsIn(), dklmdy.c_str(),
                             v.fsIn(), dklmdy.c_str());
    fragBuilder->codeAppendf("%s = float2(%s, %s);", gF.c_str(), dfdx.c_str(),
                             dfdy.c_str());
    fragBuilder->codeAppendf("%s = sqrt(dot(%s, %s));",
                             gFM.c_str(), gF.c_str(), gF.c_str());
    fragBuilder->codeAppendf("%s = %s.x*%s.x - %s.y*%s.z;",
                             func.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn());
    fragBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str());
    fragBuilder->codeAppendf("%s = half(%s / %s);",
                             edgeAlpha.c_str(), func.c_str(), gFM.c_str());
    fragBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);",
                             edgeAlpha.c_str(), edgeAlpha.c_str());
    // Add line below for smooth cubic ramp
    // fragBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);");
 
    // TODO should we really be doing this?
    if (gp.fCoverageScale != 0xff) {
        const char* coverageScale;
        fCoverageScaleUniform = uniformHandler->addUniform(nullptr,
                                                           kFragment_GrShaderFlag,
                                                           SkSLType::kFloat,
                                                           "Coverage",
                                                           &coverageScale);
        fragBuilder->codeAppendf("half4 %s = half4(half(%s) * %s);",
                                 args.fOutputCoverage, coverageScale, edgeAlpha.c_str());
    } else {
        fragBuilder->codeAppendf("half4 %s = half4(%s);", args.fOutputCoverage, edgeAlpha.c_str());
    }
}

setData()

void GrConicEffect::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 26 of file GrBezierEffect.cpp.

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

---

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

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