GrGLSLVaryingHandler Class Reference

#include <GrGLSLVarying.h>

Inheritance diagram for GrGLSLVaryingHandler:

Classes
struct	VaryingInfo

Public Types
enum class	Interpolation { kInterpolated , kCanBeFlat , kMustBeFlat }

Public Member Functions
	GrGLSLVaryingHandler (GrGLSLProgramBuilder *program)
virtual	~GrGLSLVaryingHandler ()
void	setNoPerspective ()
void	addVarying (const char *name, GrGLSLVarying *varying, Interpolation=Interpolation::kInterpolated)
void	addPassThroughAttribute (const GrShaderVar &vsVar, const char *output, Interpolation=Interpolation::kInterpolated)
void	emitAttributes (const GrGeometryProcessor &)
void	finalize ()
void	getVertexDecls (SkString *inputDecls, SkString *outputDecls) const
void	getFragDecls (SkString *inputDecls, SkString *outputDecls) const

Protected Types
typedef SkTBlockList< VaryingInfo >	VaryingList
typedef SkTBlockList< GrShaderVar >	VarArray

Protected Attributes
VaryingList	fVaryings
VarArray	fVertexInputs
VarArray	fVertexOutputs
VarArray	fFragInputs
VarArray	fFragOutputs
GrGLSLProgramBuilder *	fProgramBuilder

Private Member Functions
virtual void	onFinalize ()=0

Friends
class	GrGLSLProgramBuilder

Detailed Description

Definition at line 91 of file GrGLSLVarying.h.

Member Typedef Documentation

VarArray

typedef SkTBlockList<GrShaderVar> GrGLSLVaryingHandler::VarArray

protected

Definition at line 157 of file GrGLSLVarying.h.

VaryingList

typedef SkTBlockList<VaryingInfo> GrGLSLVaryingHandler::VaryingList

protected

Definition at line 156 of file GrGLSLVarying.h.

Member Enumeration Documentation

Interpolation

enum class GrGLSLVaryingHandler::Interpolation

strong

Enumerator
kInterpolated
kCanBeFlat
kMustBeFlat

Definition at line 112 of file GrGLSLVarying.h.

                             {
        kInterpolated,
        kCanBeFlat, // Use "flat" if it will be faster.
        kMustBeFlat // Use "flat" even if it is known to be slow.
    };

Constructor & Destructor Documentation

GrGLSLVaryingHandler()

GrGLSLVaryingHandler::GrGLSLVaryingHandler ( GrGLSLProgramBuilder *  program )

inlineexplicit

Definition at line 93 of file GrGLSLVarying.h.

        : fVaryings(kVaryingsPerBlock)
        , fVertexInputs(kVaryingsPerBlock)
        , fVertexOutputs(kVaryingsPerBlock)
        , fFragInputs(kVaryingsPerBlock)
        , fFragOutputs(kVaryingsPerBlock)
        , fProgramBuilder(program)
        , fDefaultInterpolationModifier(nullptr) {}

~GrGLSLVaryingHandler()

virtual GrGLSLVaryingHandler::~GrGLSLVaryingHandler ( )

inlinevirtual

Definition at line 102 of file GrGLSLVarying.h.

{}

Member Function Documentation

addPassThroughAttribute()

void GrGLSLVaryingHandler::addPassThroughAttribute	(	const GrShaderVar &	vsVar,
		const char *	output,
		Interpolation	interpolation = Interpolation::kInterpolated
	)

The GP can use these calls to pass a vertex shader variable directly to 'output' in the fragment shader. Though this adds code to vertex and fragment stages, 'output' is expected to be defined in the fragment shader before the call is made. TODO it might be nicer behavior to have a flag to declare output inside these calls

Definition at line 17 of file GrGLSLVarying.cpp.

                                                                                {
    SkASSERT(vsVar.getType() != SkSLType::kVoid);
    GrGLSLVarying v(vsVar.getType());
    this->addVarying(vsVar.c_str(), &v, interpolation);
    fProgramBuilder->fVS.codeAppendf("%s = %s;", v.vsOut(), vsVar.c_str());
    fProgramBuilder->fFS.codeAppendf("%s = %s;", output, v.fsIn());
}

addVarying()

void GrGLSLVaryingHandler::addVarying	(	const char *	name,
		GrGLSLVarying *	varying,
		Interpolation	interpolation = Interpolation::kInterpolated
	)

addVarying allows fine grained control for setting up varyings between stages. Calling this function will make sure all necessary decls are setup for the client. The client however is responsible for setting up all shader code (e.g "vOut = vIn;") If you just need to take an attribute and pass it through to an output value in a fragment shader, use addPassThroughAttribute. TODO convert most uses of addVarying to addPassThroughAttribute

Definition at line 43 of file GrGLSLVarying.cpp.

                                                                   {
    SkASSERT(SkSLTypeIsFloatType(varying->type()) || Interpolation::kMustBeFlat == interpolation);
    VaryingInfo& v = fVaryings.push_back();
 
    SkASSERT(varying);
    SkASSERT(SkSLType::kVoid != varying->fType);
    v.fType = varying->fType;
    v.fIsFlat = use_flat_interpolation(interpolation, *fProgramBuilder->shaderCaps());
    v.fVsOut = fProgramBuilder->nameVariable('v', name);
    v.fVisibility = kNone_GrShaderFlags;
    if (varying->isInVertexShader()) {
        varying->fVsOut = v.fVsOut.c_str();
        v.fVisibility |= kVertex_GrShaderFlag;
    }
    if (varying->isInFragmentShader()) {
        varying->fFsIn = v.fVsOut.c_str();
        v.fVisibility |= kFragment_GrShaderFlag;
    }
}

emitAttributes()

void GrGLSLVaryingHandler::emitAttributes

(

const GrGeometryProcessor &

gp

)

Definition at line 64 of file GrGLSLVarying.cpp.

                                                                       {
    for (auto attr : gp.vertexAttributes()) {
        this->addAttribute(attr.asShaderVar());
    }
    for (auto attr : gp.instanceAttributes()) {
        this->addAttribute(attr.asShaderVar());
    }
}

finalize()

void GrGLSLVaryingHandler::finalize

(

)

Definition at line 97 of file GrGLSLVarying.cpp.

                                    {
    for (const VaryingInfo& v : fVaryings.items()) {
        const char* modifier = v.fIsFlat ? "flat" : fDefaultInterpolationModifier;
        if (v.fVisibility & kVertex_GrShaderFlag) {
            fVertexOutputs.emplace_back(v.fVsOut, v.fType, GrShaderVar::TypeModifier::Out,
                                        GrShaderVar::kNonArray, SkString(), SkString(modifier));
        }
        if (v.fVisibility & kFragment_GrShaderFlag) {
            const char* fsIn = v.fVsOut.c_str();
            fFragInputs.emplace_back(SkString(fsIn), v.fType, GrShaderVar::TypeModifier::In,
                                     GrShaderVar::kNonArray, SkString(), SkString(modifier));
        }
    }
    this->onFinalize();
}

getFragDecls()

void GrGLSLVaryingHandler::getFragDecls	(	SkString *	inputDecls,
		SkString *	outputDecls
	)		const

Definition at line 125 of file GrGLSLVarying.cpp.

                                                                                         {
    // We should not have any outputs in the fragment shader when using version 1.10
    SkASSERT(SkSL::GLSLGeneration::k110 != fProgramBuilder->shaderCaps()->fGLSLGeneration ||
             fFragOutputs.empty());
    this->appendDecls(fFragInputs, inputDecls);
    this->appendDecls(fFragOutputs, outputDecls);
}

getVertexDecls()

void GrGLSLVaryingHandler::getVertexDecls	(	SkString *	inputDecls,
		SkString *	outputDecls
	)		const

Definition at line 120 of file GrGLSLVarying.cpp.

                                                                                           {
    this->appendDecls(fVertexInputs, inputDecls);
    this->appendDecls(fVertexOutputs, outputDecls);
}

onFinalize()

virtual void GrGLSLVaryingHandler::onFinalize ( )

privatepure virtual

setNoPerspective()

void GrGLSLVaryingHandler::setNoPerspective

(

)

Notifies the varying handler that this shader will never emit geometry in perspective and therefore does not require perspective-correct interpolation. When supported, this allows varyings to use the "noperspective" keyword, which means the GPU can use cheaper math for interpolation.

Definition at line 84 of file GrGLSLVarying.cpp.

                                            {
    const GrShaderCaps& caps = *fProgramBuilder->shaderCaps();
    if (!caps.fNoPerspectiveInterpolationSupport) {
        return;
    }
    if (const char* extension = caps.noperspectiveInterpolationExtensionString()) {
        int bit = 1 << GrGLSLShaderBuilder::kNoPerspectiveInterpolation_GLSLPrivateFeature;
        fProgramBuilder->fVS.addFeature(bit, extension);
        fProgramBuilder->fFS.addFeature(bit, extension);
    }
    fDefaultInterpolationModifier = "noperspective";
}

Friends And Related Function Documentation

GrGLSLProgramBuilder

friend class GrGLSLProgramBuilder

friend

Definition at line 178 of file GrGLSLVarying.h.

Member Data Documentation

fFragInputs

VarArray GrGLSLVaryingHandler::fFragInputs

protected

Definition at line 162 of file GrGLSLVarying.h.

fFragOutputs

VarArray GrGLSLVaryingHandler::fFragOutputs

protected

Definition at line 163 of file GrGLSLVarying.h.

fProgramBuilder

GrGLSLProgramBuilder* GrGLSLVaryingHandler::fProgramBuilder

protected

Definition at line 166 of file GrGLSLVarying.h.

fVaryings

VaryingList GrGLSLVaryingHandler::fVaryings

protected

Definition at line 159 of file GrGLSLVarying.h.

fVertexInputs

VarArray GrGLSLVaryingHandler::fVertexInputs

protected

Definition at line 160 of file GrGLSLVarying.h.

fVertexOutputs

VarArray GrGLSLVaryingHandler::fVertexOutputs

protected

Definition at line 161 of file GrGLSLVarying.h.

---

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

• third_party/skia/src/gpu/ganesh/glsl/GrGLSLVarying.h
• third_party/skia/src/gpu/ganesh/glsl/GrGLSLVarying.cpp