foray_samplercollection.hpp

Go to the documentation of this file.

#pragma once
#include "foray_managedimage.hpp"
#include "foray_managedresource.hpp"
#include <unordered_map>
 
namespace foray::core {
 
    class SamplerCollection;
 
    class SamplerReference
    {
        friend SamplerCollection;
 
      public:
        SamplerReference() = default;
        SamplerReference(const SamplerReference& other);
        SamplerReference(SamplerReference&& other);
        SamplerReference& operator=(const SamplerReference& other);
        virtual ~SamplerReference();
 
        SamplerReference(Context* context, const VkSamplerCreateInfo& samplerCi);
        SamplerReference(SamplerCollection* collection, const VkSamplerCreateInfo& samplerCi);
 
        void Init(Context* context, const VkSamplerCreateInfo& samplerCi);
        void Init(SamplerCollection* collection, const VkSamplerCreateInfo& samplerCi);
 
        void Destroy();
 
        inline operator VkSampler() const { return mSampler; }
 
        FORAY_GETTER_V(Sampler)
        FORAY_GETTER_V(Hash)
        FORAY_GETTER_V(Collection)
      protected:
        VkSampler mSampler = nullptr;
        uint64_t mHash = (uint64_t)0;
        SamplerCollection* mCollection = nullptr;
    };
 
    class CombinedImageSampler : public SamplerReference
    {
      public:
        CombinedImageSampler() = default;
        CombinedImageSampler(const CombinedImageSampler& other);
        CombinedImageSampler(CombinedImageSampler&& other);
        CombinedImageSampler& operator=(const CombinedImageSampler& other);
 
        CombinedImageSampler(core::Context* context, core::ManagedImage* image, const VkSamplerCreateInfo& samplerCi);
 
        void Init(core::Context* context, const VkSamplerCreateInfo& samplerCi);
        void Init(core::Context* context, core::ManagedImage* image, const VkSamplerCreateInfo& samplerCi);
 
        VkDescriptorImageInfo GetVkDescriptorInfo(VkImageLayout layout = VkImageLayout::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) const
        {
            return VkDescriptorImageInfo{.sampler = mSampler, .imageView = (!!mManagedImage) ? mManagedImage->GetImageView() : nullptr, .imageLayout = layout};
        }
 
        FORAY_PROPERTY_V(ManagedImage)
      protected:
        core::ManagedImage* mManagedImage = nullptr;
    };
 
    class SamplerCollection : public core::VulkanResource<VkObjectType::VK_OBJECT_TYPE_SAMPLER>
    {
        friend SamplerReference;
 
      public:
        SamplerCollection() = default;
 
        inline void Init(core::Context* context) { mContext = context; }
 
        inline virtual bool Exists() const override { return mSamplerInstances.size() > 0; }
 
        inline virtual void Destroy() override { ClearSamplerMap(); }
        inline virtual ~SamplerCollection() { ClearSamplerMap(); }
 
      protected:
        void GetSampler(SamplerReference& imageSampler, const VkSamplerCreateInfo& samplerCi);
 
        void Register(SamplerReference& imageSampler);
        void Unregister(SamplerReference& imageSampler);
 
        void            ClearSamplerMap();
        static uint64_t GetHash(const VkSamplerCreateInfo& samplerCi);
 
        core::Context* mContext = nullptr;
 
        struct SamplerInstance
        {
            VkSampler Sampler     = nullptr;
            uint64_t  SamplerHash = 0ULL;
            uint64_t  RefCount    = 0ULL;
        };
 
        std::unordered_map<uint64_t, SamplerInstance> mSamplerInstances;
    };
}  // namespace foray::core