GrBicubicEffect::Impl Class Reference

Inheritance diagram for GrBicubicEffect::Impl:

Public Member Functions
void	emitCode (EmitArgs &) override
Public Member Functions inherited from GrFragmentProcessor::ProgramImpl
	ProgramImpl ()=default
virtual	~ProgramImpl ()=default
void	setData (const GrGLSLProgramDataManager &pdman, const GrFragmentProcessor &processor)
int	numChildProcessors () const
ProgramImpl *	childProcessor (int index) const
void	setFunctionName (SkString name)
const char *	functionName () const
SkString	invokeChild (int childIndex, EmitArgs &parentArgs, std::string_view skslCoords={})
SkString	invokeChildWithMatrix (int childIndex, EmitArgs &parentArgs)
SkString	invokeChild (int childIndex, const char *inputColor, EmitArgs &parentArgs, std::string_view skslCoords={})
SkString	invokeChildWithMatrix (int childIndex, const char *inputColor, EmitArgs &parentArgs)
SkString	invokeChild (int childIndex, const char *inputColor, const char *destColor, EmitArgs &parentArgs, std::string_view skslCoords={})
SkString	invokeChildWithMatrix (int childIndex, const char *inputColor, const char *destColor, EmitArgs &parentArgs)

Private Member Functions
void	onSetData (const GrGLSLProgramDataManager &, const GrFragmentProcessor &) override

Additional Inherited Members
Public Types inherited from GrFragmentProcessor::ProgramImpl
using	UniformHandle = GrGLSLUniformHandler::UniformHandle
using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Detailed Description

Definition at line 34 of file GrBicubicEffect.cpp.

Member Function Documentation

emitCode()

void GrBicubicEffect::Impl::emitCode ( EmitArgs &  args )

overridevirtual

Implements GrFragmentProcessor::ProgramImpl.

Definition at line 45 of file GrBicubicEffect.cpp.

                                                 {
    const GrBicubicEffect& bicubicEffect = args.fFp.cast<GrBicubicEffect>();
 
    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
 
    const char* coeffs;
    fCoefficientUni = args.fUniformHandler->addUniform(&args.fFp, kFragment_GrShaderFlag,
                                                       SkSLType::kHalf4x4, "coefficients", &coeffs);
    // We determine our fractional offset (f) within the texel. We then snap coord to a texel
    // center. The snap prevents cases where the starting coords are near a texel boundary and
    // offsets with imperfect precision would cause us to skip/double hit a texel.
    // The use of "texel" above is somewhat abstract as we're sampling a child processor. It is
    // assumed the child processor represents something akin to a nearest neighbor sampled texture.
    if (bicubicEffect.fDirection == GrBicubicEffect::Direction::kXY) {
        fragBuilder->codeAppendf("float2 coord = %s - float2(0.5);", args.fSampleCoord);
        fragBuilder->codeAppend("half2 f = half2(fract(coord));");
        fragBuilder->codeAppend("coord += 0.5 - f;");
        fragBuilder->codeAppendf("half4 wx = %s * half4(1.0, f.x, f.x * f.x, f.x * f.x * f.x);",
                                 coeffs);
        fragBuilder->codeAppendf("half4 wy = %s * half4(1.0, f.y, f.y * f.y, f.y * f.y * f.y);",
                                 coeffs);
        fragBuilder->codeAppend("half4 rowColors[4];");
        for (int y = 0; y < 4; ++y) {
            for (int x = 0; x < 4; ++x) {
                auto coord = SkSL::String::printf("coord + float2(%d, %d)", x - 1, y - 1);
                auto childStr = this->invokeChild(0, args, coord);
                fragBuilder->codeAppendf("rowColors[%d] = %s;", x, childStr.c_str());
            }
            fragBuilder->codeAppendf(
                    "half4 s%d = wx.x * rowColors[0] + wx.y * rowColors[1] + wx.z * rowColors[2] + "
                    "wx.w * rowColors[3];",
                    y);
        }
        fragBuilder->codeAppend(
                "half4 bicubicColor = wy.x * s0 + wy.y * s1 + wy.z * s2 + wy.w * s3;");
    } else {
        const char* d = bicubicEffect.fDirection == Direction::kX ? "x" : "y";
        fragBuilder->codeAppendf("float coord = %s.%s - 0.5;", args.fSampleCoord, d);
        fragBuilder->codeAppend("half f = half(fract(coord));");
        fragBuilder->codeAppend("coord += 0.5 - f;");
        fragBuilder->codeAppend("half f2 = f * f;");
        fragBuilder->codeAppendf("half4 w = %s * half4(1.0, f, f2, f2 * f);", coeffs);
        fragBuilder->codeAppend("half4 c[4];");
        for (int i = 0; i < 4; ++i) {
            std::string coord;
            if (bicubicEffect.fDirection == Direction::kX) {
                coord = SkSL::String::printf("float2(coord + %d, %s.y)", i - 1, args.fSampleCoord);
            } else {
                coord = SkSL::String::printf("float2(%s.x, coord + %d)", args.fSampleCoord, i - 1);
            }
            auto childStr = this->invokeChild(0, args, coord);
            fragBuilder->codeAppendf("c[%d] = %s;", i, childStr.c_str());
        }
        fragBuilder->codeAppend(
                "half4 bicubicColor = c[0] * w.x + c[1] * w.y + c[2] * w.z + c[3] * w.w;");
    }
    // Bicubic can send colors out of range, so clamp to get them back in (source) gamut.
    // The kind of clamp we have to do depends on the alpha type.
    switch (bicubicEffect.fClamp) {
        case Clamp::kUnpremul:
            fragBuilder->codeAppend("bicubicColor = saturate(bicubicColor);");
            break;
        case Clamp::kPremul:
            fragBuilder->codeAppend("bicubicColor.a = saturate(bicubicColor.a);");
            fragBuilder->codeAppend(
                    "bicubicColor.rgb = max(half3(0.0), min(bicubicColor.rgb, bicubicColor.aaa));");
            break;
    }
    fragBuilder->codeAppendf("return bicubicColor;");
}

onSetData()

void GrBicubicEffect::Impl::onSetData ( const GrGLSLProgramDataManager &  , const GrFragmentProcessor &    )

overrideprivatevirtual

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

Reimplemented from GrFragmentProcessor::ProgramImpl.

Definition at line 116 of file GrBicubicEffect.cpp.

                                                                     {
    auto& bicubicEffect = fp.cast<GrBicubicEffect>();
 
    if (fKernel.B != bicubicEffect.fKernel.B || fKernel.C != bicubicEffect.fKernel.C) {
        fKernel = bicubicEffect.fKernel;
        pdm.setSkM44(fCoefficientUni, SkImageShader::CubicResamplerMatrix(fKernel.B, fKernel.C));
    }
}

---

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

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