GPUObjects.hpp

#pragma once
 
#include "Common.hpp"
#include "graphics/GPUTypes.hpp"
 
#undef VK_NULL_HANDLE
#undef VK_DEFINE_HANDLE
#include <volk/volk.h>
 
// Forward declarations.
VK_DEFINE_HANDLE(VmaAllocation);
class Buffer;
 
class GPUTexture {
public:
    GPUTexture(const Layout & layoutFormat);
 
    void clean();
    
    GPUTexture & operator=(const GPUTexture &) = delete;
    
    GPUTexture(const GPUTexture &) = delete;
    
    GPUTexture & operator=(GPUTexture &&) = delete;
    
    GPUTexture(GPUTexture &&) = delete;
 
    static unsigned int getChannelsCount(const Layout& format);
 
    static bool isSRGB(const Layout& format);
 
    VkFormat format; 
    VkImageAspectFlags aspect; 
    
    uint channels; 
 
    VkImage image = VK_NULL_HANDLE; 
    VkImageView view = VK_NULL_HANDLE; 
 
    struct MipViews {
        std::vector<VkImageView> views; 
        VkImageView mipView; 
    };
    std::vector<MipViews> views;  
 
    VmaAllocation data = VK_NULL_HANDLE; 
    ImTextureID imgui = (ImTextureID)VK_NULL_HANDLE; 
 
    std::vector<std::vector<VkImageLayout>> layouts; 
    VkImageLayout defaultLayout; 
 
    bool owned = true; 
 
};
 
 
class GPUBuffer {
public:
 
    GPUBuffer(BufferType atype);
 
    void clean();
 
    GPUBuffer & operator=(const GPUBuffer &) = delete;
 
    GPUBuffer(const GPUBuffer &) = delete;
 
    GPUBuffer & operator=(GPUBuffer &&) = delete;
 
    GPUBuffer(GPUBuffer &&) = delete;
 
    VkBuffer buffer = VK_NULL_HANDLE; 
    VmaAllocation data = VK_NULL_HANDLE; 
    char* mapped = nullptr; 
    bool mappable = false; 
    
};
 
 
class GPUMesh {
public:
    
    std::unique_ptr<Buffer> vertexBuffer; 
    std::unique_ptr<Buffer> indexBuffer; 
 
    size_t count = 0; 
    
    void clean();
 
    bool isEquivalent(const GPUMesh& other) const;
    
    GPUMesh() = default;
    
    GPUMesh & operator=(const GPUMesh &) = delete;
    
    GPUMesh(const GPUMesh &) = delete;
    
    GPUMesh & operator=(GPUMesh &&) = delete;
    
    GPUMesh(GPUMesh &&) = delete;
 
    struct State {
        std::vector<VkVertexInputAttributeDescription> attributes; 
        std::vector<VkVertexInputBindingDescription> bindings; 
        std::vector<VkBuffer> buffers; 
        std::vector<VkDeviceSize> offsets; 
 
        bool isEquivalent(const State& other) const;
    };
 
    State state; 
};