ImageCube.hpp

#pragma once
 
#include "PixelBullet/Filesystem/Resources/Resource.hpp"
#include "PixelBullet/Filesystem/VirtualPath.hpp"
#include "PixelBullet/Graphics/Images/Image.hpp"
#include "PixelBullet/Serialization/Node.hpp"
 
#include <glm/glm.hpp>
 
#include <string>
#include <typeindex>
#include <vector>
 
namespace PixelBullet
{
    class Bitmap;
 
    class ImageCube : public Image, public Resource
    {
    public:
        static std::shared_ptr<ImageCube> Create(const Node& node);
 
        static std::shared_ptr<ImageCube>
        Create(const VirtualPath& assetPath, const std::string& fileSuffix, VkFilter filter = VK_FILTER_LINEAR,
               VkSamplerAddressMode addressMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, bool anisotropic = true,
               bool mipmap = true);
 
        explicit ImageCube(const VirtualPath& assetPath, std::string fileSuffix = ".png",
                           VkFilter filter = VK_FILTER_LINEAR,
                           VkSamplerAddressMode addressMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                           bool anisotropic = true, bool mipmap = true, bool load = true);
 
        explicit ImageCube(const glm::uvec2& extent, VkFormat format = VK_FORMAT_R8G8B8A8_UNORM,
                           VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                           VkImageUsageFlags usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
                           VkFilter filter = VK_FILTER_LINEAR,
                           VkSamplerAddressMode addressMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                           VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT, bool anisotropic = false,
                           bool mipmap = false);
 
        explicit ImageCube(std::unique_ptr<Bitmap>&& bitmap, VkFormat format = VK_FORMAT_R8G8B8A8_UNORM,
                           VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                           VkImageUsageFlags usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
                           VkFilter filter = VK_FILTER_LINEAR,
                           VkSamplerAddressMode addressMode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
                           VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT, bool anisotropic = false,
                           bool mipmap = false);
 
        std::unique_ptr<Bitmap> GetBitmap(uint32_t mipLevel = 0) const;
 
        void SetPixels(const uint8_t* pixels, uint32_t layerCount, uint32_t baseArrayLayer);
 
        std::type_index GetTypeIndex() const override
        {
            return typeid(ImageCube);
        }
 
        const VirtualPath& GetAssetPath() const
        {
            return m_AssetPath;
        }
        const std::string& GetFileSuffix() const
        {
            return m_FileSuffix;
        }
        const std::vector<std::string>& GetFileSides() const
        {
            return m_FileSides;
        }
        bool IsAnisotropic() const
        {
            return m_Anisotropic;
        }
        bool IsMipmap() const
        {
            return m_Mipmap;
        }
        uint32_t GetComponents() const
        {
            return m_Components;
        }
 
    private:
        friend const Node& operator>>(const Node& node, ImageCube& image);
        friend Node& operator<<(Node& node, const ImageCube& image);
 
        void Load(std::unique_ptr<Bitmap> loadBitmap = nullptr);
 
    private:
        VirtualPath m_AssetPath;
        std::string m_FileSuffix;
        std::vector<std::string> m_FileSides = { "Right", "Left", "Top", "Bottom", "Back", "Front" };
 
        bool m_Anisotropic;
        bool m_Mipmap;
        uint32_t m_Components = 0;
    };
} // namespace PixelBullet