GrVkSampler Class Reference

#include <GrVkSampler.h>

Inheritance diagram for GrVkSampler:

Classes
struct	Key

Public Member Functions
VkSampler	sampler () const
const VkSampler *	samplerPtr () const
uint32_t	uniqueID () const
Public Member Functions inherited from GrVkManagedResource
	GrVkManagedResource (const GrVkGpu *gpu)
Public Member Functions inherited from GrManagedResource
	GrManagedResource ()
virtual	~GrManagedResource ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static GrVkSampler *	Create (GrVkGpu *gpu, GrSamplerState, const skgpu::VulkanYcbcrConversionInfo &)
static SK_END_REQUIRE_DENSE Key	GenerateKey (GrSamplerState, const skgpu::VulkanYcbcrConversionInfo &)
static const Key &	GetKey (const GrVkSampler &sampler)
static uint32_t	Hash (const Key &key)

Additional Inherited Members
Protected Attributes inherited from GrVkManagedResource
const GrVkGpu *	fGpu

Detailed Description

Definition at line 23 of file GrVkSampler.h.

Member Function Documentation

Create()

GrVkSampler * GrVkSampler::Create ( GrVkGpu *  gpu, GrSamplerState  samplerState, const skgpu::VulkanYcbcrConversionInfo &  ycbcrInfo  )

static

Definition at line 39 of file GrVkSampler.cpp.

                                                                                  {
    static VkFilter vkMinFilterModes[] = {
        VK_FILTER_NEAREST,
        VK_FILTER_LINEAR,
        VK_FILTER_LINEAR
    };
    static VkFilter vkMagFilterModes[] = {
        VK_FILTER_NEAREST,
        VK_FILTER_LINEAR,
        VK_FILTER_LINEAR
    };
 
    VkSamplerCreateInfo createInfo;
    memset(&createInfo, 0, sizeof(VkSamplerCreateInfo));
    createInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
    createInfo.pNext = nullptr;
    createInfo.flags = 0;
    createInfo.magFilter = vkMagFilterModes[static_cast<int>(samplerState.filter())];
    createInfo.minFilter = vkMinFilterModes[static_cast<int>(samplerState.filter())];
    createInfo.mipmapMode = mipmap_mode_to_vk_sampler_mipmap_mode(samplerState.mipmapMode());
    createInfo.addressModeU = wrap_mode_to_vk_sampler_address(samplerState.wrapModeX());
    createInfo.addressModeV = wrap_mode_to_vk_sampler_address(samplerState.wrapModeY());
    createInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; // Shouldn't matter
    createInfo.mipLodBias = 0.0f;
    createInfo.anisotropyEnable = samplerState.isAniso() ? VK_TRUE : VK_FALSE;
    createInfo.maxAnisotropy = std::min(static_cast<float>(samplerState.maxAniso()),
                                        gpu->vkCaps().maxSamplerAnisotropy());
    createInfo.compareEnable = VK_FALSE;
    createInfo.compareOp = VK_COMPARE_OP_NEVER;
    // Vulkan doesn't have a direct mapping of GL's nearest or linear filters for minFilter since
    // there is always a mipmapMode. To get the same effect as GL we can set minLod = maxLod = 0.0.
    // This works since our min and mag filters are the same (this forces us to use mag on the 0
    // level mip). If the filters weren't the same we could set min = 0 and max = 0.25 to force
    // the minFilter on mip level 0.
    createInfo.minLod = 0.0f;
    bool useMipMaps = samplerState.mipmapped() == skgpu::Mipmapped::kYes;
    createInfo.maxLod = !useMipMaps ? 0.0f : 10000.0f;
    createInfo.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
    createInfo.unnormalizedCoordinates = VK_FALSE;
 
    VkSamplerYcbcrConversionInfo conversionInfo;
    GrVkSamplerYcbcrConversion* ycbcrConversion = nullptr;
    if (ycbcrInfo.isValid()) {
        SkASSERT(gpu->vkCaps().supportsYcbcrConversion());
 
        ycbcrConversion =
                gpu->resourceProvider().findOrCreateCompatibleSamplerYcbcrConversion(ycbcrInfo);
        if (!ycbcrConversion) {
            return nullptr;
        }
 
        conversionInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
        conversionInfo.pNext = nullptr;
        conversionInfo.conversion = ycbcrConversion->ycbcrConversion();
 
        createInfo.pNext = &conversionInfo;
 
        VkFilter chromaFilter = ycbcrInfo.fChromaFilter;
        VkFormatFeatureFlags flags = ycbcrInfo.fFormatFeatures;
        if (!SkToBool(flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
            createInfo.magFilter = VK_FILTER_NEAREST;
            createInfo.minFilter = VK_FILTER_NEAREST;
            // This doesn't explicitly do anything itself, but if we don't support separate
            // reconstruction filters below, then we need the chromaFilter to match the mag/min here
            // so we set it nearest. Because we don't currently update the VulkanYcbcrConversionInfo
            // that we're querying here, this logic around the chromaFilter must match the logic in
            // the SetupSamplerYcbcrConversionInfo helper function.
            chromaFilter = VK_FILTER_NEAREST;
        }
        if (!(flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT)) {
            createInfo.magFilter = chromaFilter;
            createInfo.minFilter = chromaFilter;
        }
 
        // Required values when using ycbcr conversion
        createInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        createInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        createInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        createInfo.anisotropyEnable = VK_FALSE;
        createInfo.unnormalizedCoordinates = VK_FALSE;
    }
 
    VkSampler sampler;
    VkResult result;
    GR_VK_CALL_RESULT(gpu, result, CreateSampler(gpu->device(), &createInfo, nullptr, &sampler));
    if (result != VK_SUCCESS) {
        ycbcrConversion->unref();
        return nullptr;
    }
 
    return new GrVkSampler(gpu, sampler, ycbcrConversion, GenerateKey(samplerState, ycbcrInfo));
}

GenerateKey()

GrVkSampler::Key GrVkSampler::GenerateKey ( GrSamplerState  samplerState, const skgpu::VulkanYcbcrConversionInfo &  ycbcrInfo  )

static

Definition at line 142 of file GrVkSampler.cpp.

                                                                                           {
    // In VK the max aniso value is specified in addition to min/mag/mip filters and the
    // driver is encouraged to consider the other filter settings when doing aniso.
    return {samplerState.asKey(/*anisoIsOrthogonal=*/true),
            GrVkSamplerYcbcrConversion::GenerateKey(ycbcrInfo)};
}

GetKey()

static const Key & GrVkSampler::GetKey ( const GrVkSampler &  sampler )

inlinestatic

Definition at line 52 of file GrVkSampler.h.

{ return sampler.fKey; }

Hash()

static uint32_t GrVkSampler::Hash ( const Key &  key )

inlinestatic

Definition at line 53 of file GrVkSampler.h.

                                         {
        return SkChecksum::Hash32(&key, sizeof(Key));
    }

sampler()

VkSampler GrVkSampler::sampler ( ) const

inline

Definition at line 29 of file GrVkSampler.h.

{ return fSampler; }

samplerPtr()

const VkSampler * GrVkSampler::samplerPtr ( ) const

inline

Definition at line 30 of file GrVkSampler.h.

{ return &fSampler; }

uniqueID()

uint32_t GrVkSampler::uniqueID ( ) const

inline

Definition at line 57 of file GrVkSampler.h.

{ return fUniqueID; }

---

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

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