GrDistanceFieldA8TextGeoProc::Impl Class Reference

Inheritance diagram for GrDistanceFieldA8TextGeoProc::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 39 of file GrDistanceFieldGeoProc.cpp.

Member Function Documentation

onEmitCode()

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

inlineoverrideprivatevirtual

Implements GrGeometryProcessor::ProgramImpl.

Definition at line 67 of file GrDistanceFieldGeoProc.cpp.

                                                              {
        const GrDistanceFieldA8TextGeoProc& dfTexEffect =
                args.fGeomProc.cast<GrDistanceFieldA8TextGeoProc>();
        GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
 
        GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
        GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
        GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
        // emit attributes
        varyingHandler->emitAttributes(dfTexEffect);
 
        const char* atlasDimensionsInvName;
        fAtlasDimensionsInvUniform = uniformHandler->addUniform(nullptr,
                                                                kVertex_GrShaderFlag,
                                                                SkSLType::kFloat2,
                                                                "AtlasDimensionsInv",
                                                                &atlasDimensionsInvName);
#ifdef SK_GAMMA_APPLY_TO_A8
        // adjust based on gamma
        const char* distanceAdjustUniName = nullptr;
        // width, height, 1/(3*width)
        fDistanceAdjustUni = uniformHandler->addUniform(nullptr, kFragment_GrShaderFlag,
                                                        SkSLType::kHalf, "DistanceAdjust",
                                                        &distanceAdjustUniName);
#endif
 
        // Setup pass through color
        fragBuilder->codeAppendf("half4 %s;\n", args.fOutputColor);
        varyingHandler->addPassThroughAttribute(dfTexEffect.fInColor.asShaderVar(),
                                                args.fOutputColor);
 
        // Setup position
        gpArgs->fPositionVar = dfTexEffect.fInPosition.asShaderVar();
        WriteLocalCoord(vertBuilder,
                        uniformHandler,
                        *args.fShaderCaps,
                        gpArgs,
                        gpArgs->fPositionVar,
                        dfTexEffect.fLocalMatrix,
                        &fLocalMatrixUniform);
 
        // add varyings
        GrGLSLVarying uv, texIdx, st;
        append_index_uv_varyings(args,
                                 dfTexEffect.numTextureSamplers(),
                                 dfTexEffect.fInTextureCoords.name(),
                                 atlasDimensionsInvName,
                                 &uv,
                                 &texIdx,
                                 &st);
 
        bool isUniformScale = (dfTexEffect.fFlags & kUniformScale_DistanceFieldEffectMask) ==
                                                    kUniformScale_DistanceFieldEffectMask;
        bool isSimilarity   = SkToBool(dfTexEffect.fFlags & kSimilarity_DistanceFieldEffectFlag  );
        bool isGammaCorrect = SkToBool(dfTexEffect.fFlags & kGammaCorrect_DistanceFieldEffectFlag);
        bool isAliased      = SkToBool(dfTexEffect.fFlags & kAliased_DistanceFieldEffectFlag     );
 
        // Use highp to work around aliasing issues
        fragBuilder->codeAppendf("float2 uv = %s;\n", uv.fsIn());
        fragBuilder->codeAppend("half4 texColor;");
        append_multitexture_lookup(args, dfTexEffect.numTextureSamplers(),
                                   texIdx, "uv", "texColor");
 
        fragBuilder->codeAppend("half distance = "
                      SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ");");
#ifdef SK_GAMMA_APPLY_TO_A8
        // adjust width based on gamma
        fragBuilder->codeAppendf("distance -= %s;", distanceAdjustUniName);
#endif
 
        fragBuilder->codeAppend("half afwidth;");
        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.
            // We use the y gradient because there is a bug in the Mali 400 in the x direction.
 
            // this gives us a smooth step across approximately one fragment
            if (args.fShaderCaps->fAvoidDfDxForGradientsWhenPossible) {
                fragBuilder->codeAppendf("half st_grad_len = length(half2(dFdy(%s)));", st.fsIn());
            } else {
                fragBuilder->codeAppendf("half st_grad_len = length(half2(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(float2(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);");
        }
 
        if (isAliased) {
            fragBuilder->codeAppend("half val = distance > 0 ? 1.0 : 0.0;");
        } else if (isGammaCorrect) {
            // 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:
            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 GrDistanceFieldA8TextGeoProc::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 41 of file GrDistanceFieldGeoProc.cpp.

                                                               {
        const GrDistanceFieldA8TextGeoProc& dfa8gp = geomProc.cast<GrDistanceFieldA8TextGeoProc>();
 
#ifdef SK_GAMMA_APPLY_TO_A8
        float distanceAdjust = dfa8gp.fDistanceAdjust;
        if (distanceAdjust != fDistanceAdjust) {
            fDistanceAdjust = distanceAdjust;
            pdman.set1f(fDistanceAdjustUni, distanceAdjust);
        }
#endif
 
        const SkISize& atlasDimensions = dfa8gp.fAtlasDimensions;
        SkASSERT(SkIsPow2(atlasDimensions.fWidth) && SkIsPow2(atlasDimensions.fHeight));
 
        if (fAtlasDimensions != atlasDimensions) {
            pdman.set2f(fAtlasDimensionsInvUniform,
                        1.0f / atlasDimensions.fWidth,
                        1.0f / atlasDimensions.fHeight);
            fAtlasDimensions = atlasDimensions;
        }
        SetTransform(pdman, shaderCaps, fLocalMatrixUniform, dfa8gp.fLocalMatrix, &fLocalMatrix);
    }

---

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

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