GrPathTessellationShader::Impl Class Reference

#include <GrPathTessellationShader.h>

Inheritance diagram for GrPathTessellationShader::Impl:

Public Member Functions
void	onEmitCode (EmitArgs &, GrGPArgs *) final
void	setData (const GrGLSLProgramDataManager &, const GrShaderCaps &, const GrGeometryProcessor &) 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)

Protected Member Functions
virtual void	emitVertexCode (const GrShaderCaps &, const GrPathTessellationShader &, GrGLSLVertexBuilder *, GrGLSLVaryingHandler *, GrGPArgs *)=0

Protected Attributes
GrGLSLUniformHandler::UniformHandle	fAffineMatrixUniform
GrGLSLUniformHandler::UniformHandle	fTranslateUniform
GrGLSLUniformHandler::UniformHandle	fColorUniform
SkString	fVaryingColorName

Static Protected Attributes
static const char *	kEvalRationalCubicFn

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

Detailed Description

Definition at line 120 of file GrPathTessellationShader.h.

Member Function Documentation

emitVertexCode()

virtual void GrPathTessellationShader::Impl::emitVertexCode ( const GrShaderCaps &  , const GrPathTessellationShader &  , GrGLSLVertexBuilder *  , GrGLSLVaryingHandler *  , GrGPArgs *    )

protectedpure virtual

onEmitCode()

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

final

Definition at line 303 of file GrPathTessellationShader.cpp.

                                                                              {
    const auto& shader = args.fGeomProc.cast<GrPathTessellationShader>();
    args.fVaryingHandler->emitAttributes(shader);
 
    // Vertex shader.
    const char* affineMatrix, *translate;
    fAffineMatrixUniform = args.fUniformHandler->addUniform(nullptr, kVertex_GrShaderFlag,
                                                            SkSLType::kFloat4, "affineMatrix",
                                                            &affineMatrix);
    fTranslateUniform = args.fUniformHandler->addUniform(nullptr, kVertex_GrShaderFlag,
                                                         SkSLType::kFloat2, "translate", &translate);
    args.fVertBuilder->codeAppendf("float2x2 AFFINE_MATRIX = float2x2(%s.xy, %s.zw);",
                                   affineMatrix, affineMatrix);
    args.fVertBuilder->codeAppendf("float2 TRANSLATE = %s;", translate);
    this->emitVertexCode(*args.fShaderCaps,
                         shader,
                         args.fVertBuilder,
                         args.fVaryingHandler,
                         gpArgs);
 
    // Fragment shader.
    if (!(shader.fAttribs & PatchAttribs::kColor)) {
        const char* color;
        fColorUniform = args.fUniformHandler->addUniform(nullptr, kFragment_GrShaderFlag,
                                                         SkSLType::kHalf4, "color", &color);
        args.fFragBuilder->codeAppendf("half4 %s = %s;", args.fOutputColor, color);
    } else {
        args.fFragBuilder->codeAppendf("half4 %s = %s;",
                                       args.fOutputColor, fVaryingColorName.c_str());
    }
    args.fFragBuilder->codeAppendf("const half4 %s = half4(1);", args.fOutputCoverage);
}

setData()

void GrPathTessellationShader::Impl::setData ( const GrGLSLProgramDataManager &  pdman, const GrShaderCaps &  , const GrGeometryProcessor &  geomProc  )

override

Definition at line 336 of file GrPathTessellationShader.cpp.

                                                                                                 {
    const auto& shader = geomProc.cast<GrPathTessellationShader>();
    const SkMatrix& m = shader.viewMatrix();
    pdman.set4f(fAffineMatrixUniform, m.getScaleX(), m.getSkewY(), m.getSkewX(), m.getScaleY());
    pdman.set2f(fTranslateUniform, m.getTranslateX(), m.getTranslateY());
 
    if (!(shader.fAttribs & PatchAttribs::kColor)) {
        const SkPMColor4f& color = shader.color();
        pdman.set4f(fColorUniform, color.fR, color.fG, color.fB, color.fA);
    }
}

Member Data Documentation

fAffineMatrixUniform

GrGLSLUniformHandler::UniformHandle GrPathTessellationShader::Impl::fAffineMatrixUniform

protected

Definition at line 141 of file GrPathTessellationShader.h.

fColorUniform

GrGLSLUniformHandler::UniformHandle GrPathTessellationShader::Impl::fColorUniform

protected

Definition at line 143 of file GrPathTessellationShader.h.

fTranslateUniform

GrGLSLUniformHandler::UniformHandle GrPathTessellationShader::Impl::fTranslateUniform

protected

Definition at line 142 of file GrPathTessellationShader.h.

fVaryingColorName

SkString GrPathTessellationShader::Impl::fVaryingColorName

protected

Definition at line 144 of file GrPathTessellationShader.h.

kEvalRationalCubicFn

const char * GrPathTessellationShader::Impl::kEvalRationalCubicFn

staticprotected

Initial value:

=
"float3 safe_mix(float3 a, float3 b, float T, float one_minus_T) {"
    "return a*one_minus_T + b*T;"
"}"
"float2 eval_rational_cubic(float4x3 P, float T) {"
    "float one_minus_T = 1.0 - T;"
    "float3 ab = safe_mix(P[0], P[1], T, one_minus_T);"
    "float3 bc = safe_mix(P[1], P[2], T, one_minus_T);"
    "float3 cd = safe_mix(P[2], P[3], T, one_minus_T);"
    "float3 abc = safe_mix(ab, bc, T, one_minus_T);"
    "float3 bcd = safe_mix(bc, cd, T, one_minus_T);"
    "float3 abcd = safe_mix(abc, bcd, T, one_minus_T);"
    "return abcd.xy / abcd.z;"
"}"

Definition at line 133 of file GrPathTessellationShader.h.

---

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

• third_party/skia/src/gpu/ganesh/tessellate/GrPathTessellationShader.h
• third_party/skia/src/gpu/ganesh/tessellate/GrPathTessellationShader.cpp