GrDistanceFieldPathGeoProc::Impl Class Reference

Inheritance diagram for GrDistanceFieldPathGeoProc::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 &args, GrGPArgs *gpArgs) 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 332 of file GrDistanceFieldGeoProc.cpp.

Member Function Documentation

onEmitCode()

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

inlineoverrideprivatevirtual

Implements GrGeometryProcessor::ProgramImpl.

Definition at line 354 of file GrDistanceFieldGeoProc.cpp.

                                                              {
        const GrDistanceFieldPathGeoProc& dfPathEffect =
                args.fGeomProc.cast<GrDistanceFieldPathGeoProc>();
 
        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
 
        GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
        GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
        GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
        // emit attributes
        varyingHandler->emitAttributes(dfPathEffect);
 
        const char* atlasDimensionsInvName;
        fAtlasDimensionsInvUniform = uniformHandler->addUniform(nullptr,
                                                                kVertex_GrShaderFlag,
                                                                SkSLType::kFloat2,
                                                                "AtlasDimensionsInv",
                                                                &atlasDimensionsInvName);
 
        GrGLSLVarying uv, texIdx, st;
        append_index_uv_varyings(args,
                                 dfPathEffect.numTextureSamplers(),
                                 dfPathEffect.fInTextureCoords.name(),
                                 atlasDimensionsInvName,
                                 &uv,
                                 &texIdx,
                                 &st);
 
        // setup pass through color
        fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);
        varyingHandler->addPassThroughAttribute(dfPathEffect.fInColor.asShaderVar(),
                                                args.fOutputColor);
 
        // Setup position (output position is pass through, local coords are transformed)
        gpArgs->fPositionVar = dfPathEffect.fInPosition.asShaderVar();
        WriteLocalCoord(vertBuilder,
                        uniformHandler,
                        *args.fShaderCaps,
                        gpArgs,
                        gpArgs->fPositionVar,
                        dfPathEffect.fLocalMatrix,
                        &fLocalMatrixUniform);
 
        // Use highp to work around aliasing issues
        fragBuilder->codeAppendf("float2 uv = %s;", uv.fsIn());
        fragBuilder->codeAppend("half4 texColor;");
        append_multitexture_lookup(args, dfPathEffect.numTextureSamplers(), texIdx, "uv",
                                   "texColor");
 
        fragBuilder->codeAppend("half distance = "
            SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ");");
 
        fragBuilder->codeAppend("half afwidth;");
        bool isUniformScale = (dfPathEffect.fFlags & kUniformScale_DistanceFieldEffectMask) ==
                                                     kUniformScale_DistanceFieldEffectMask;
        bool isSimilarity   = SkToBool(dfPathEffect.fFlags & kSimilarity_DistanceFieldEffectFlag  );
        bool isGammaCorrect = SkToBool(dfPathEffect.fFlags & kGammaCorrect_DistanceFieldEffectFlag);
        if (isUniformScale) {
            // For uniform scale, we adjust for the effect of the transformation on the distance
            // by using the length of the gradient of the t coordinate in the y direction.
            // We use st coordinates to ensure we're mapping 1:1 from texel space to pixel space.
 
            // this gives us a smooth step across approximately one fragment
            if (args.fShaderCaps->fAvoidDfDxForGradientsWhenPossible) {
                fragBuilder->codeAppendf(
                        "afwidth = abs(" SK_DistanceFieldAAFactor "*half(dFdy(%s.y)));", st.fsIn());
            } else {
                fragBuilder->codeAppendf(
                        "afwidth = abs(" SK_DistanceFieldAAFactor "*half(dFdx(%s.x)));", st.fsIn());
            }
        } else if (isSimilarity) {
            // For similarity transform, we adjust the effect of the transformation on the distance
            // by using the length of the gradient of the texture coordinates. We use st coordinates
            // to ensure we're mapping 1:1 from texel space to pixel space.
 
            // this gives us a smooth step across approximately one fragment
            if (args.fShaderCaps->fAvoidDfDxForGradientsWhenPossible) {
                fragBuilder->codeAppendf("half st_grad_len = half(length(dFdy(%s)));", st.fsIn());
            } else {
                fragBuilder->codeAppendf("half st_grad_len = half(length(dFdx(%s)));", st.fsIn());
            }
            fragBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*st_grad_len);");
        } else {
            // For general transforms, to determine the amount of correction we multiply a unit
            // vector pointing along the SDF gradient direction by the Jacobian of the st coords
            // (which is the inverse transform for this fragment) and take the length of the result.
            fragBuilder->codeAppend("half2 dist_grad = half2(dFdx(distance), "
                                                            "dFdy(distance));");
            // the length of the gradient may be 0, so we need to check for this
            // this also compensates for the Adreno, which likes to drop tiles on division by 0
            fragBuilder->codeAppend("half dg_len2 = dot(dist_grad, dist_grad);");
            fragBuilder->codeAppend("if (dg_len2 < 0.0001) {");
            fragBuilder->codeAppend("dist_grad = half2(0.7071, 0.7071);");
            fragBuilder->codeAppend("} else {");
            fragBuilder->codeAppend("dist_grad = dist_grad*half(inversesqrt(dg_len2));");
            fragBuilder->codeAppend("}");
 
            fragBuilder->codeAppendf("half2 Jdx = half2(dFdx(%s));", st.fsIn());
            fragBuilder->codeAppendf("half2 Jdy = half2(dFdy(%s));", st.fsIn());
            fragBuilder->codeAppend("half2 grad = half2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,");
            fragBuilder->codeAppend("                   dist_grad.x*Jdx.y + dist_grad.y*Jdy.y);");
 
            // this gives us a smooth step across approximately one fragment
            fragBuilder->codeAppend("afwidth = " SK_DistanceFieldAAFactor "*length(grad);");
        }
        // The smoothstep falloff compensates for the non-linear sRGB response curve. If we are
        // doing gamma-correct rendering (to an sRGB or F16 buffer), then we actually want distance
        // mapped linearly to coverage, so use a linear step:
        if (isGammaCorrect) {
            fragBuilder->codeAppend(
                "half val = saturate((distance + afwidth) / (2.0 * afwidth));");
        } else {
            fragBuilder->codeAppend("half val = smoothstep(-afwidth, afwidth, distance);");
        }
 
        fragBuilder->codeAppendf("half4 %s = half4(val);", args.fOutputCoverage);
    }

setData()

void GrDistanceFieldPathGeoProc::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 334 of file GrDistanceFieldGeoProc.cpp.

                                                               {
        const GrDistanceFieldPathGeoProc& dfpgp = geomProc.cast<GrDistanceFieldPathGeoProc>();
 
        // We always set the matrix uniform. It's used to transform from from device to local
        // for the local coord variable.
        SetTransform(pdman, shaderCaps, fLocalMatrixUniform, dfpgp.fLocalMatrix, &fLocalMatrix);
 
        const SkISize& atlasDimensions = dfpgp.fAtlasDimensions;
        SkASSERT(SkIsPow2(atlasDimensions.fWidth) && SkIsPow2(atlasDimensions.fHeight));
        if (fAtlasDimensions != atlasDimensions) {
            pdman.set2f(fAtlasDimensionsInvUniform,
                        1.0f / atlasDimensions.fWidth,
                        1.0f / atlasDimensions.fHeight);
            fAtlasDimensions = atlasDimensions;
        }
    }

---

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

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