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
virtual void	emitCode (EmitArgs &)=0
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)

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;");
}

---

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

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