VulkanResource.h

#pragma once
 
// Standard.
#include <variant>
#include <memory>
#include <mutex>
#include <format>
#include <string>
 
// Custom.
#include "render/general/resource/GpuResource.h"
#include "io/Logger.h"
#include "material/TextureFilteringPreference.h"
 
// External.
#include "VulkanMemoryAllocator/include/vk_mem_alloc.h"
#include "ktxvulkan.h"
 
namespace ne {
    class VulkanResourceManager;
    class Renderer;
 
    class VulkanResource : public GpuResource {
        // Only resource manager can create this resource
        // (simply because only manager has a memory allocator object).
        friend class VulkanResourceManager;
 
    public:
        VulkanResource() = delete;
        VulkanResource(const VulkanResource&) = delete;
        VulkanResource& operator=(const VulkanResource&) = delete;
 
        virtual ~VulkanResource() override;
 
        inline VkBuffer getInternalBufferResource() const { return pBufferResource; };
 
        inline VkImageView getInternalImageView() const { return pImageView; }
 
        inline VkImageView getInternalCubemapImageView(size_t iCubemapFaceIndex = 0) {
            // Make sure we won't access out of bounds.
            if (iCubemapFaceIndex >= vCubeMapViews.size()) [[unlikely]] { // <- remove if no log
                // Log an error because this case is marked as unlikely.
                // ! REMOVE [[unlikely]] IF REMOVING LOG !
                Logger::get().error(std::format(
                    "cubemap view was requested on resource \"{}\" with an out of bounds index "
                    "{} while cubemap view count is {}",
                    getResourceName(),
                    iCubemapFaceIndex,
                    vCubeMapViews.size()));
                return nullptr;
            }
 
            return vCubeMapViews[iCubemapFaceIndex];
        }
 
        inline VkImageView getInternalImageViewDepthAspect() const { return pDepthAspectImageView; }
 
        inline VkImage getInternalImage() const { return pImageResource; }
 
        bool isStorageResource() const;
 
        VkSampler getTextureSamplerForThisImage() const;
 
        inline std::pair<std::recursive_mutex, VmaAllocation>* getInternalResourceMemory() {
            // Self check:
            if (optionalKtxTexture.has_value()) [[unlikely]] {
                Error error(std::format(
                    "failed to query VmaAllocation of resource \"{}\" because "
                    "this resource is a KTX texture that was loaded via external library "
                    "(accessing VmaAllocation of such object is complicated, if you want "
                    "to access VkDeviceMemory it's a good time to implement such a getter "
                    "because VkDeviceMemory is available for KTX textures)",
                    getResourceName()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
 
            return &mtxResourceMemory;
        }
 
    private:
        VulkanResource(
            VulkanResourceManager* pResourceManager,
            const std::string& sResourceName,
            std::variant<VkBuffer, VkImage> pInternalResource,
            bool isStorageResource,
            VmaAllocation pResourceMemory,
            unsigned int iElementSizeInBytes,
            unsigned int iElementCount);
 
        VulkanResource(
            VulkanResourceManager* pResourceManager,
            const std::string& sResourceName,
            ktxVulkanTexture ktxTexture,
            TextureFilteringPreference filteringPreference);
 
        static std::variant<std::unique_ptr<VulkanResource>, Error> create(
            VulkanResourceManager* pResourceManager,
            const std::string& sResourceName,
            VmaAllocator pMemoryAllocator,
            const VkBufferCreateInfo& bufferInfo,
            const VmaAllocationCreateInfo& allocationInfo,
            unsigned int iElementSizeInBytes,
            unsigned int iElementCount);
 
        static std::variant<std::unique_ptr<VulkanResource>, Error> create(
            VulkanResourceManager* pResourceManager,
            const std::string& sResourceName,
            VmaAllocator pMemoryAllocator,
            const VkImageCreateInfo& imageInfo,
            const VmaAllocationCreateInfo& allocationInfo,
            std::optional<VkImageAspectFlags> viewDescription,
            bool bIsCubeMapView = false);
 
        static std::variant<std::unique_ptr<VulkanResource>, Error> create(
            VulkanResourceManager* pResourceManager,
            const std::string& sResourceName,
            ktxVulkanTexture ktxTexture,
            TextureFilteringPreference filteringPreference);
 
        std::optional<ktxVulkanTexture> optionalKtxTexture;
 
        VkBuffer pBufferResource = nullptr;
 
        VkImage pImageResource = nullptr;
 
        VkImageView pImageView = nullptr;
 
        VkImageView pDepthAspectImageView = nullptr;
 
        std::vector<VkImageView> vCubeMapViews;
 
        std::pair<std::recursive_mutex, VmaAllocation> mtxResourceMemory;
 
        const TextureFilteringPreference textureFilteringPreference;
 
        const bool isUsedAsStorageResource = false;
    };
} // namespace ne