GrGeometryProcessor::ProgramImpl Class Reference

#include <GrGeometryProcessor.h>

Inheritance diagram for GrGeometryProcessor::ProgramImpl:

Classes
struct	EmitArgs
struct	FPCoords
struct	GrGPArgs

Public Types
using	UniformHandle = GrGLSLProgramDataManager::UniformHandle
using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle
using	FPCoordsMap = std::unordered_map< const GrFragmentProcessor *, FPCoords >

Public Member Functions
virtual	~ProgramImpl ()=default
std::tuple< FPCoordsMap, GrShaderVar >	emitCode (EmitArgs &, const GrPipeline &pipeline)
void	emitTransformCode (GrGLSLVertexBuilder *vb, GrGLSLUniformHandler *uniformHandler)
virtual void	setData (const GrGLSLProgramDataManager &, const GrShaderCaps &, const GrGeometryProcessor &)=0

Static Public Member Functions
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
static constexpr int	kMatrixKeyBits = 2

Protected Member Functions
void	setupUniformColor (GrGLSLFPFragmentBuilder *fragBuilder, GrGLSLUniformHandler *uniformHandler, const char *outputName, UniformHandle *colorUniform)

Static Protected Member Functions
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)

Private Member Functions
virtual void	onEmitCode (EmitArgs &, GrGPArgs *)=0

Detailed Description

Definition at line 261 of file GrGeometryProcessor.h.

Member Typedef Documentation

FPCoordsMap

using GrGeometryProcessor::ProgramImpl::FPCoordsMap = std::unordered_map<const GrFragmentProcessor*, FPCoords>

Definition at line 271 of file GrGeometryProcessor.h.

SamplerHandle

using GrGeometryProcessor::ProgramImpl::SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Definition at line 264 of file GrGeometryProcessor.h.

UniformHandle

using GrGeometryProcessor::ProgramImpl::UniformHandle = GrGLSLProgramDataManager::UniformHandle

Definition at line 263 of file GrGeometryProcessor.h.

Constructor & Destructor Documentation

~ProgramImpl()

virtual GrGeometryProcessor::ProgramImpl::~ProgramImpl ( )

virtualdefault

Member Function Documentation

AddMatrixKeys()

static uint32_t GrGeometryProcessor::ProgramImpl::AddMatrixKeys ( const GrShaderCaps &  shaderCaps, uint32_t  flags, const SkMatrix &  viewMatrix, const SkMatrix &  localMatrix  )

inlinestatic

Definition at line 357 of file GrGeometryProcessor.h.

                                                               {
        // Shifting to make room for the matrix keys shouldn't lose bits
        SkASSERT(((flags << (2 * kMatrixKeyBits)) >> (2 * kMatrixKeyBits)) == flags);
        return (flags << (2 * kMatrixKeyBits)) |
               ComputeMatrixKeys(shaderCaps, viewMatrix, localMatrix);
    }

ComputeMatrixKey()

static uint32_t GrGeometryProcessor::ProgramImpl::ComputeMatrixKey ( const GrShaderCaps &  caps, const SkMatrix &  mat  )

inlinestatic

Definition at line 335 of file GrGeometryProcessor.h.

                                                                                    {
        if (!caps.fReducedShaderMode) {
            if (mat.isIdentity()) {
                return 0b00;
            }
            if (mat.isScaleTranslate()) {
                return 0b01;
            }
        }
        if (!mat.hasPerspective()) {
            return 0b10;
        }
        return 0b11;
    }

ComputeMatrixKeys()

static uint32_t GrGeometryProcessor::ProgramImpl::ComputeMatrixKeys ( const GrShaderCaps &  shaderCaps, const SkMatrix &  viewMatrix, const SkMatrix &  localMatrix  )

inlinestatic

Definition at line 350 of file GrGeometryProcessor.h.

                                                                   {
        return (ComputeMatrixKey(shaderCaps, viewMatrix) << kMatrixKeyBits) |
               ComputeMatrixKey(shaderCaps, localMatrix);
    }

emitCode()

std::tuple< FPCoordsMap, GrShaderVar > GrGeometryProcessor::ProgramImpl::emitCode	(	EmitArgs &	,
		const GrPipeline &	pipeline
	)

Emits the code from this geometry processor into the shaders. For any FP in the pipeline that has its input coords implemented by the GP as a varying, the varying will be accessible in the returned map and should be used when the FP code is emitted. The FS variable containing the GP's output local coords is also returned.

emitTransformCode()

void ProgramImpl::emitTransformCode	(	GrGLSLVertexBuilder *	vb,
		GrGLSLUniformHandler *	uniformHandler
	)

Called after all effect emitCode() functions, to give the processor a chance to write out additional transformation code now that all uniforms have been emitted. It generates the final code for assigning transformed coordinates to the varyings recorded in the call to collectTransforms(). This must happen after FP code emission so that it has access to any uniforms the FPs registered for uniform sample matrix invocations.

Definition at line 237 of file GrGeometryProcessor.cpp.

                                                                                                 {
    // Because descendant varyings may be computed using the varyings of ancestor FPs we make
    // sure to visit the varyings according to FP pre-order traversal by dumping them into a
    // priority queue.
    using FPAndInfo = std::tuple<const GrFragmentProcessor*, TransformInfo>;
    auto compare = [](const FPAndInfo& a, const FPAndInfo& b) {
        return std::get<1>(a).traversalOrder > std::get<1>(b).traversalOrder;
    };
    std::priority_queue<FPAndInfo, std::vector<FPAndInfo>, decltype(compare)> pq(compare);
    std::for_each(fTransformVaryingsMap.begin(), fTransformVaryingsMap.end(), [&pq](auto entry) {
        pq.push(entry);
    });
    for (; !pq.empty(); pq.pop()) {
        const auto& [fp, info] = pq.top();
        // If we recorded a transform info, its sample matrix must be uniform
        SkASSERT(fp->sampleUsage().isUniformMatrix());
        GrShaderVar uniform = uniformHandler->liftUniformToVertexShader(
                *fp->parent(), SkString(SkSL::SampleUsage::MatrixUniformName()));
        // Start with this matrix and accumulate additional matrices as we walk up the FP tree
        // to either the base coords or an ancestor FP that has an associated varying.
        SkString transformExpression = uniform.getName();
 
        // If we hit an ancestor with a varying on our walk up then save off the varying as the
        // input to our accumulated transformExpression. Start off assuming we'll reach the root.
        GrShaderVar inputCoords = info.inputCoords;
 
        for (const auto* base = fp->parent(); base; base = base->parent()) {
            if (auto iter = fTransformVaryingsMap.find(base); iter != fTransformVaryingsMap.end()) {
                // Can stop here, as this varying already holds all transforms from higher FPs
                // We'll apply the residual transformExpression we've accumulated up from our
                // starting FP to this varying.
                inputCoords = iter->second.varying.vsOutVar();
                break;
            } else if (base->sampleUsage().isUniformMatrix()) {
                // Accumulate any matrices along the path to either the original local/device coords
                // or a parent varying. Getting here means this FP was sampled with a uniform matrix
                // but all uses of coords below here in the FP hierarchy are beneath additional
                // matrix samples and thus this node wasn't assigned a varying.
                GrShaderVar parentUniform = uniformHandler->liftUniformToVertexShader(
                        *base->parent(), SkString(SkSL::SampleUsage::MatrixUniformName()));
                transformExpression.appendf(" * %s", parentUniform.getName().c_str());
            } else if (base->sampleUsage().isFragCoord()) {
                // Our chain of matrices starts here and is based on the device space position.
                break;
            } else {
                // This intermediate FP is just a pass through and doesn't need to be built
                // in to the expression, but we must visit its parents in case they add transforms.
                SkASSERT(base->sampleUsage().isPassThrough() || !base->sampleUsage().isSampled());
            }
        }
 
        SkString inputStr;
        if (inputCoords.getType() == SkSLType::kFloat2) {
            inputStr = SkStringPrintf("%s.xy1", inputCoords.getName().c_str());
        } else {
            SkASSERT(inputCoords.getType() == SkSLType::kFloat3);
            inputStr = inputCoords.getName();
        }
 
        vb->codeAppend("{\n");
        if (info.varying.type() == SkSLType::kFloat2) {
            if (vb->getProgramBuilder()->shaderCaps()->fNonsquareMatrixSupport) {
                vb->codeAppendf("%s = float3x2(%s) * %s",
                                info.varying.vsOut(),
                                transformExpression.c_str(),
                                inputStr.c_str());
            } else {
                vb->codeAppendf("%s = (%s * %s).xy",
                                info.varying.vsOut(),
                                transformExpression.c_str(),
                                inputStr.c_str());
            }
        } else {
            SkASSERT(info.varying.type() == SkSLType::kFloat3);
            vb->codeAppendf("%s = %s * %s",
                            info.varying.vsOut(),
                            transformExpression.c_str(),
                            inputStr.c_str());
        }
        vb->codeAppend(";\n");
        vb->codeAppend("}\n");
    }
    // We don't need this map anymore.
    fTransformVaryingsMap.clear();
}

onEmitCode()

virtual void GrGeometryProcessor::ProgramImpl::onEmitCode ( EmitArgs &  , GrGPArgs *    )

privatepure virtual

setData()

virtual void GrGeometryProcessor::ProgramImpl::setData ( const GrGLSLProgramDataManager &  , const GrShaderCaps &  , const GrGeometryProcessor &    )

pure virtual

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.

Implemented in GrRRectShadowGeoProc::Impl, GrConicEffect::Impl, GrQuadEffect::Impl, GrBitmapTextGeoProc::Impl, GrDistanceFieldA8TextGeoProc::Impl, GrDistanceFieldPathGeoProc::Impl, and GrDistanceFieldLCDTextGeoProc::Impl.

SetTransform()

void ProgramImpl::SetTransform ( const GrGLSLProgramDataManager &  pdman, const GrShaderCaps &  shaderCaps, const UniformHandle &  uniform, const SkMatrix &  matrix, SkMatrix *  state = nullptr  )

staticprotected

Definition at line 340 of file GrGeometryProcessor.cpp.

                                                {
    if (!uniform.isValid() || (state && SkMatrixPriv::CheapEqual(*state, matrix))) {
        // No update needed
        return;
    }
    if (state) {
        *state = matrix;
    }
    if (matrix.isScaleTranslate() && !shaderCaps.fReducedShaderMode) {
        // ComputeMatrixKey and writeX() assume the uniform is a float4 (can't assert since nothing
        // is exposed on a handle, but should be caught lower down).
        float values[4] = {matrix.getScaleX(), matrix.getTranslateX(),
                           matrix.getScaleY(), matrix.getTranslateY()};
        pdman.set4fv(uniform, 1, values);
    } else {
        pdman.setSkMatrix(uniform, matrix);
    }
}

setupUniformColor()

void ProgramImpl::setupUniformColor ( GrGLSLFPFragmentBuilder *  fragBuilder, GrGLSLUniformHandler *  uniformHandler, const char *  outputName, UniformHandle *  colorUniform  )

protected

Definition at line 323 of file GrGeometryProcessor.cpp.

                                                                 {
    SkASSERT(colorUniform);
    const char* stagedLocalVarName;
    *colorUniform = uniformHandler->addUniform(nullptr,
                                               kFragment_GrShaderFlag,
                                               SkSLType::kHalf4,
                                               "Color",
                                               &stagedLocalVarName);
    fragBuilder->codeAppendf("%s = %s;", outputName, stagedLocalVarName);
    if (fragBuilder->getProgramBuilder()->shaderCaps()->fMustObfuscateUniformColor) {
        fragBuilder->codeAppendf("%s = max(%s, half4(0));", outputName, outputName);
    }
}

WriteLocalCoord()

void ProgramImpl::WriteLocalCoord ( GrGLSLVertexBuilder *  vertBuilder, GrGLSLUniformHandler *  uniformHandler, const GrShaderCaps &  shaderCaps, GrGPArgs *  gpArgs, GrShaderVar  localVar, const SkMatrix &  localMatrix, UniformHandle *  localMatrixUniform  )

staticprotected

Definition at line 474 of file GrGeometryProcessor.cpp.

                                                                     {
    write_vertex_position(vertBuilder,
                          uniformHandler,
                          shaderCaps,
                          localVar,
                          localMatrix,
                          "localMatrix",
                          &gpArgs->fLocalCoordVar,
                          localMatrixUniform);
}

WriteOutputPosition() [1/2]

static void GrGeometryProcessor::ProgramImpl::WriteOutputPosition ( GrGLSLVertexBuilder *  , GrGLSLUniformHandler *  , const GrShaderCaps &  , GrGPArgs *  , const char *  posName, const SkMatrix &  viewMatrix, UniformHandle *  viewMatrixUniform  )

staticprotected

WriteOutputPosition() [2/2]

static void GrGeometryProcessor::ProgramImpl::WriteOutputPosition ( GrGLSLVertexBuilder *  , GrGPArgs *  , const char *  posName  )

staticprotected

Member Data Documentation

kMatrixKeyBits

constexpr int GrGeometryProcessor::ProgramImpl::kMatrixKeyBits = 2

inlinestaticconstexpr

Definition at line 366 of file GrGeometryProcessor.h.

---

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

• third_party/skia/src/gpu/ganesh/GrGeometryProcessor.h
• third_party/skia/src/gpu/ganesh/GrGeometryProcessor.cpp