GrVkUniformHandler Class Reference

#include <GrVkUniformHandler.h>

Inheritance diagram for GrVkUniformHandler:

Classes
struct	VkUniformInfo

Public Types
enum	{ kUniformBufferDescSet = 0 , kSamplerDescSet = 1 , kInputDescSet = 2 , kLastDescSet = kInputDescSet }
enum	{ kUniformBinding = 0 , kInputBinding = 0 }
enum	{ kDstInputAttachmentIndex = 0 }
enum	Layout { kStd140Layout = 0 , kStd430Layout = 1 , kLastLayout = kStd430Layout }
typedef SkTBlockList< VkUniformInfo >	UniformInfoArray
Public Types inherited from GrGLSLUniformHandler
using	UniformHandle = GrGLSLProgramDataManager::UniformHandle

Public Member Functions
	~GrVkUniformHandler () override
const GrShaderVar &	getUniformVariable (UniformHandle u) const override
const char *	getUniformCStr (UniformHandle u) const override
uint32_t	getRTFlipOffset () const
int	numUniforms () const override
UniformInfo &	uniform (int idx) override
const UniformInfo &	uniform (int idx) const override
bool	usePushConstants () const
uint32_t	currentOffset () const
Public Member Functions inherited from GrGLSLUniformHandler
virtual	~GrGLSLUniformHandler ()
UniformHandle	addUniform (const GrProcessor *owner, uint32_t visibility, SkSLType type, const char *name, const char **outName=nullptr)
UniformHandle	addUniformArray (const GrProcessor *owner, uint32_t visibility, SkSLType type, const char *name, int arrayCount, const char **outName=nullptr)
GrShaderVar	getUniformMapping (const GrProcessor &owner, SkString rawName) const
GrShaderVar	liftUniformToVertexShader (const GrProcessor &owner, SkString rawName)

Static Public Attributes
static const int	kUniformsPerBlock = 8
static constexpr int	kDescSetCount = kLastDescSet + 1
static constexpr int	kLayoutCount = kLastLayout + 1

Private Member Functions
UniformHandle	internalAddUniformArray (const GrProcessor *owner, uint32_t visibility, SkSLType type, const char *name, bool mangleName, int arrayCount, const char **outName) override
SamplerHandle	addSampler (const GrBackendFormat &, GrSamplerState, const skgpu::Swizzle &, const char *name, const GrShaderCaps *) override
SamplerHandle	addInputSampler (const skgpu::Swizzle &swizzle, const char *name) override
const char *	samplerVariable (SamplerHandle handle) const override
skgpu::Swizzle	samplerSwizzle (SamplerHandle handle) const override
const char *	inputSamplerVariable (SamplerHandle handle) const override
skgpu::Swizzle	inputSamplerSwizzle (SamplerHandle handle) const override
void	appendUniformDecls (GrShaderFlags, SkString *) const override

Friends
class	GrVkPipelineStateBuilder
class	GrVkDescriptorSetManager

Additional Inherited Members
Protected Member Functions inherited from GrGLSLUniformHandler
	GrGLSLUniformHandler (GrGLSLProgramBuilder *program)
Protected Attributes inherited from GrGLSLUniformHandler
GrGLSLProgramBuilder *	fProgramBuilder

Detailed Description

Definition at line 19 of file GrVkUniformHandler.h.

Member Typedef Documentation

UniformInfoArray

typedef SkTBlockList<VkUniformInfo> GrVkUniformHandler::UniformInfoArray

Definition at line 63 of file GrVkUniformHandler.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kUniformBufferDescSet	Binding a descriptor set invalidates all higher index descriptor sets. We must bind in the order of this enumeration. Samplers are after Uniforms because GrOps can specify GP textures as dynamic state, meaning they get rebound for each draw in a pipeline while uniforms are bound once before all the draws. We bind input attachments after samplers so those also need to be rebound if we bind new samplers.
kSamplerDescSet
kInputDescSet
kLastDescSet

Definition at line 23 of file GrVkUniformHandler.h.

         {
        /**
         * Binding a descriptor set invalidates all higher index descriptor sets. We must bind
         * in the order of this enumeration. Samplers are after Uniforms because GrOps can specify
         * GP textures as dynamic state, meaning they get rebound for each draw in a pipeline while
         * uniforms are bound once before all the draws. We bind input attachments after samplers
         * so those also need to be rebound if we bind new samplers.
         */
        kUniformBufferDescSet = 0,
        kSamplerDescSet = 1,
        kInputDescSet = 2,
 
        kLastDescSet = kInputDescSet,
    };

anonymous enum

anonymous enum

Enumerator
kUniformBinding
kInputBinding

Definition at line 40 of file GrVkUniformHandler.h.

         {
        kUniformBinding = 0,
        kInputBinding = 0,
    };

anonymous enum

anonymous enum

Enumerator
kDstInputAttachmentIndex

Definition at line 44 of file GrVkUniformHandler.h.

         {
        kDstInputAttachmentIndex = 0
    };

Layout

enum GrVkUniformHandler::Layout

Enumerator
kStd140Layout
kStd430Layout
kLastLayout

Definition at line 49 of file GrVkUniformHandler.h.

                {
        kStd140Layout = 0,
        kStd430Layout = 1,
 
        kLastLayout = kStd430Layout
    };

Constructor & Destructor Documentation

~GrVkUniformHandler()

GrVkUniformHandler::~GrVkUniformHandler ( )

override

Definition at line 194 of file GrVkUniformHandler.cpp.

                                        {
    for (VkUniformInfo& sampler : fSamplers.items()) {
        if (sampler.fImmutableSampler) {
            sampler.fImmutableSampler->unref();
            sampler.fImmutableSampler = nullptr;
        }
    }
}

Member Function Documentation

addInputSampler()

GrGLSLUniformHandler::SamplerHandle GrVkUniformHandler::addInputSampler ( const skgpu::Swizzle &  swizzle, const char *  name  )

overrideprivatevirtual

Reimplemented from GrGLSLUniformHandler.

Definition at line 300 of file GrVkUniformHandler.cpp.

                                                           {
    SkASSERT(name && strlen(name));
    SkASSERT(fInputUniform.fVariable.getType() == SkSLType::kVoid);
 
    const char prefix = 'u';
    SkString mangleName = fProgramBuilder->nameVariable(prefix, name, /*mangle=*/true);
 
    auto layoutQualifier = SkStringPrintf("vulkan, input_attachment_index=%d, set=%d, binding=%d",
                                          kDstInputAttachmentIndex,
                                          kInputDescSet,
                                          kInputBinding);
 
    fInputUniform = {GrShaderVar{std::move(mangleName),
                                 SkSLType::kInput,
                                 GrShaderVar::TypeModifier::None,
                                 GrShaderVar::kNonArray,
                                 std::move(layoutQualifier),
                                 SkString()},
                     kFragment_GrShaderFlag,
                     nullptr,
                     SkString(name)};
    fInputSwizzle = swizzle;
    return GrGLSLUniformHandler::SamplerHandle(0);
}

addSampler()

GrGLSLUniformHandler::SamplerHandle GrVkUniformHandler::addSampler ( const GrBackendFormat &  backendFormat, GrSamplerState  state, const skgpu::Swizzle &  swizzle, const char *  name, const GrShaderCaps *  shaderCaps  )

overrideprivatevirtual

Implements GrGLSLUniformHandler.

Definition at line 252 of file GrVkUniformHandler.cpp.

                                        {
    SkASSERT(name && strlen(name));
 
    const char prefix = 'u';
    SkString mangleName = fProgramBuilder->nameVariable(prefix, name, /*mangle=*/true);
 
    SkString layoutQualifier;
    layoutQualifier.appendf("vulkan, set=%d, binding=%d", kSamplerDescSet, fSamplers.count());
 
    VkUniformInfo tempInfo;
    tempInfo.fVariable =
            GrShaderVar{std::move(mangleName),
                        SkSLCombinedSamplerTypeForTextureType(backendFormat.textureType()),
                        GrShaderVar::TypeModifier::None,
                        GrShaderVar::kNonArray,
                        std::move(layoutQualifier),
                        SkString()};
 
    tempInfo.fVisibility = kFragment_GrShaderFlag;
    tempInfo.fOwner      = nullptr;
    tempInfo.fRawName    = SkString(name);
    tempInfo.fOffsets[0] = 0;
    tempInfo.fOffsets[1] = 0;
 
    fSamplers.push_back(tempInfo);
 
    // Check if we are dealing with an external texture and store the needed information if so.
    auto ycbcrInfo = GrBackendFormats::GetVkYcbcrConversionInfo(backendFormat);
    if (ycbcrInfo && ycbcrInfo->isValid()) {
        GrVkGpu* gpu = static_cast<GrVkPipelineStateBuilder*>(fProgramBuilder)->gpu();
        GrVkSampler* sampler = gpu->resourceProvider().findOrCreateCompatibleSampler(state,
                                                                                     *ycbcrInfo);
        fSamplers.back().fImmutableSampler = sampler;
        if (!sampler) {
            return {};
        }
    }
 
    fSamplerSwizzles.push_back(swizzle);
    SkASSERT(fSamplerSwizzles.size() == fSamplers.count());
    return GrGLSLUniformHandler::SamplerHandle(fSamplers.count() - 1);
}

appendUniformDecls()

void GrVkUniformHandler::appendUniformDecls ( GrShaderFlags  visibility, SkString *  out  ) const

overrideprivatevirtual

Implements GrGLSLUniformHandler.

Definition at line 326 of file GrVkUniformHandler.cpp.

                                                                                         {
    for (const VkUniformInfo& sampler : fSamplers.items()) {
        SkASSERT(sampler.fVariable.getType() == SkSLType::kTexture2DSampler ||
                 sampler.fVariable.getType() == SkSLType::kTextureExternalSampler);
        if (visibility == sampler.fVisibility) {
            sampler.fVariable.appendDecl(fProgramBuilder->shaderCaps(), out);
            out->append(";\n");
        }
    }
    if (fInputUniform.fVariable.getType() == SkSLType::kInput) {
        if (visibility == fInputUniform.fVisibility) {
            SkASSERT(visibility == kFragment_GrShaderFlag);
            fInputUniform.fVariable.appendDecl(fProgramBuilder->shaderCaps(), out);
            out->append(";\n");
        }
    }
 
#ifdef SK_DEBUG
    bool firstOffsetCheck = false;
    for (const VkUniformInfo& localUniform : fUniforms.items()) {
        if (!firstOffsetCheck) {
            // Check to make sure we are starting our offset at 0 so the offset qualifier we
            // set on each variable in the uniform block is valid.
            SkASSERT(0 == localUniform.fOffsets[kStd140Layout] &&
                     0 == localUniform.fOffsets[kStd430Layout]);
            firstOffsetCheck = true;
        }
    }
#endif
 
    // At this point we determine whether we'll be using push constants based on the
    // uniforms set so far. Later checks will use the internal bool we set here to
    // keep things consistent.
    this->determineIfUsePushConstants();
    SkString uniformsString;
    for (const VkUniformInfo& localUniform : fUniforms.items()) {
        if (visibility & localUniform.fVisibility) {
            if (SkSLTypeCanBeUniformValue(localUniform.fVariable.getType())) {
                Layout layout = fUsePushConstants ? kStd430Layout : kStd140Layout;
                uniformsString.appendf("layout(offset=%u) ", localUniform.fOffsets[layout]);
                localUniform.fVariable.appendDecl(fProgramBuilder->shaderCaps(), &uniformsString);
                uniformsString.append(";\n");
            }
        }
    }
 
    if (!uniformsString.isEmpty()) {
        if (fUsePushConstants) {
            out->append("layout (vulkan, push_constant) ");
        } else {
            out->appendf("layout (vulkan, set=%d, binding=%d) ",
                         kUniformBufferDescSet, kUniformBinding);
        }
        out->append("uniform uniformBuffer\n{\n");
        out->appendf("%s\n};\n", uniformsString.c_str());
    }
}

currentOffset()

uint32_t GrVkUniformHandler::currentOffset ( ) const

inline

Definition at line 92 of file GrVkUniformHandler.h.

                                   {
        return fUsePushConstants ? fCurrentOffsets[kStd430Layout] : fCurrentOffsets[kStd140Layout];
    }

getRTFlipOffset()

uint32_t GrVkUniformHandler::getRTFlipOffset

(

)

const

Returns the offset that the RTFlip synthetic uniform should use if it needs to be created.

Definition at line 384 of file GrVkUniformHandler.cpp.

                                                   {
    Layout layout = fUsePushConstants ? kStd430Layout : kStd140Layout;
    uint32_t currentOffset = fCurrentOffsets[layout];
    return get_aligned_offset(&currentOffset, SkSLType::kFloat2, 0, layout);
}

getUniformCStr()

const char * GrVkUniformHandler::getUniformCStr ( UniformHandle  u ) const

inlineoverridevirtual

Shortcut for getUniformVariable(u).c_str()

Implements GrGLSLUniformHandler.

Definition at line 71 of file GrVkUniformHandler.h.

                                                               {
        return this->getUniformVariable(u).c_str();
    }

getUniformVariable()

const GrShaderVar & GrVkUniformHandler::getUniformVariable ( UniformHandle  u ) const

inlineoverridevirtual

Implements GrGLSLUniformHandler.

Definition at line 67 of file GrVkUniformHandler.h.

                                                                          {
        return fUniforms.item(u.toIndex()).fVariable;
    }

inputSamplerSwizzle()

skgpu::Swizzle GrVkUniformHandler::inputSamplerSwizzle ( SamplerHandle  handle ) const

inlineoverrideprivatevirtual

Reimplemented from GrGLSLUniformHandler.

Definition at line 143 of file GrVkUniformHandler.h.

                                                                          {
        SkASSERT(handle.toIndex() == 0);
        return fInputSwizzle;
    }

inputSamplerVariable()

const char * GrVkUniformHandler::inputSamplerVariable ( SamplerHandle  handle ) const

inlineoverrideprivatevirtual

Reimplemented from GrGLSLUniformHandler.

Definition at line 136 of file GrVkUniformHandler.h.

                                                                          {
        // Currently we will only ever have one input sampler variable, though in the future we may
        // expand to allow more inputs. For now assert that any requested handle maps to index 0,
        // to make sure we didn't add multiple input samplers.
        SkASSERT(handle.toIndex() == 0);
        return fInputUniform.fVariable.c_str();
    }

internalAddUniformArray()

GrGLSLUniformHandler::UniformHandle GrVkUniformHandler::internalAddUniformArray ( const GrProcessor *  owner, uint32_t  visibility, SkSLType  type, const char *  name, bool  mangleName, int  arrayCount, const char **  outName  )

overrideprivatevirtual

Implements GrGLSLUniformHandler.

Definition at line 203 of file GrVkUniformHandler.cpp.

                                                                                         {
    SkASSERT(name && strlen(name));
    SkASSERT(SkSLTypeCanBeUniformValue(type));
 
    // TODO this is a bit hacky, lets think of a better way.  Basically we need to be able to use
    // the uniform view matrix name in the GP, and the GP is immutable so it has to tell the PB
    // exactly what name it wants to use for the uniform view matrix.  If we prefix anythings, then
    // the names will mismatch.  I think the correct solution is to have all GPs which need the
    // uniform view matrix, they should upload the view matrix in their setData along with regular
    // uniforms.
    char prefix = 'u';
    if ('u' == name[0] || !strncmp(name, GR_NO_MANGLE_PREFIX, strlen(GR_NO_MANGLE_PREFIX))) {
        prefix = '\0';
    }
    SkString resolvedName = fProgramBuilder->nameVariable(prefix, name, mangleName);
 
    VkUniformInfo tempInfo;
    tempInfo.fVariable = GrShaderVar{std::move(resolvedName),
                                     type,
                                     GrShaderVar::TypeModifier::None,
                                     arrayCount};
 
    tempInfo.fVisibility = visibility;
    tempInfo.fOwner      = owner;
    tempInfo.fRawName    = SkString(name);
 
    for (int layout = 0; layout < kLayoutCount; ++layout) {
        tempInfo.fOffsets[layout] = get_aligned_offset(&fCurrentOffsets[layout],
                                                       type,
                                                       arrayCount,
                                                       layout);
    }
 
    fUniforms.push_back(tempInfo);
 
    if (outName) {
        *outName = fUniforms.back().fVariable.c_str();
    }
 
    return GrGLSLUniformHandler::UniformHandle(fUniforms.count() - 1);
}

numUniforms()

int GrVkUniformHandler::numUniforms ( ) const

inlineoverridevirtual

Implements GrGLSLUniformHandler.

Definition at line 80 of file GrVkUniformHandler.h.

                                     {
        return fUniforms.count();
    }

samplerSwizzle()

skgpu::Swizzle GrVkUniformHandler::samplerSwizzle ( SamplerHandle  handle ) const

inlineoverrideprivatevirtual

Implements GrGLSLUniformHandler.

Definition at line 125 of file GrVkUniformHandler.h.

                                                                     {
        return fSamplerSwizzles[handle.toIndex()];
    }

samplerVariable()

const char * GrVkUniformHandler::samplerVariable ( SamplerHandle  handle ) const

inlineoverrideprivatevirtual

Implements GrGLSLUniformHandler.

Definition at line 122 of file GrVkUniformHandler.h.

                                                                     {
        return fSamplers.item(handle.toIndex()).fVariable.c_str();
    }

uniform() [1/2]

const UniformInfo & GrVkUniformHandler::uniform ( int  idx ) const

inlineoverridevirtual

Implements GrGLSLUniformHandler.

Definition at line 87 of file GrVkUniformHandler.h.

                                                       {
        return fUniforms.item(idx);
    }

uniform() [2/2]

UniformInfo & GrVkUniformHandler::uniform ( int  idx )

inlineoverridevirtual

Implements GrGLSLUniformHandler.

Definition at line 84 of file GrVkUniformHandler.h.

                                           {
        return fUniforms.item(idx);
    }

usePushConstants()

bool GrVkUniformHandler::usePushConstants ( ) const

inline

Definition at line 91 of file GrVkUniformHandler.h.

{ return fUsePushConstants; }

Friends And Related Symbol Documentation

GrVkDescriptorSetManager

friend class GrVkDescriptorSetManager

friend

Definition at line 166 of file GrVkUniformHandler.h.

GrVkPipelineStateBuilder

friend class GrVkPipelineStateBuilder

friend

Definition at line 165 of file GrVkUniformHandler.h.

Member Data Documentation

kDescSetCount

constexpr int GrVkUniformHandler::kDescSetCount = kLastDescSet + 1

staticconstexpr

Definition at line 37 of file GrVkUniformHandler.h.

kLayoutCount

constexpr int GrVkUniformHandler::kLayoutCount = kLastLayout + 1

staticconstexpr

Definition at line 55 of file GrVkUniformHandler.h.

kUniformsPerBlock

const int GrVkUniformHandler::kUniformsPerBlock = 8

static

Definition at line 21 of file GrVkUniformHandler.h.

---

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

• third_party/skia/src/gpu/ganesh/vk/GrVkUniformHandler.h
• third_party/skia/src/gpu/ganesh/vk/GrVkUniformHandler.cpp