Swapchain.h

#pragma once
 
#include "Common.h"
 
#include "Buffer.h"
#include "Device.h"
#include "Error.h"
#include "Image.h"
 
namespace Mandrill
{
    class Swapchain
    {
    public:
        MANDRILL_NON_COPYABLE(Swapchain)
 
        
        MANDRILL_API Swapchain(ptr<Device> pDevice, uint32_t framesInFlight = 2);
 
        MANDRILL_API ~Swapchain();
 
        MANDRILL_API void recreate();
 
        MANDRILL_API VkCommandBuffer acquireNextImage();
 
        MANDRILL_API void present(VkCommandBuffer cmd, ptr<Image> pImage);
 
        MANDRILL_API void requestScreenshot();
 
        MANDRILL_API std::vector<uint8_t> waitForScreenshot();
 
        MANDRILL_API VkSwapchainKHR getSwapchain() const
        {
            return mSwapchain;
        }
 
        MANDRILL_API VkImage getImage() const
        {
            return mImages[mImageIndex];
        }
 
        MANDRILL_API const std::vector<VkImage>& getImages() const
        {
            return mImages;
        }
 
        MANDRILL_API VkImageView getImageView() const
        {
            return mImageViews[mImageIndex];
        }
 
        MANDRILL_API const std::vector<VkImageView>& getImageViews() const
        {
            return mImageViews;
        }
 
        MANDRILL_API VkDescriptorSet getImageDescriptorSet() const
        {
            return mDescriptorSets[mImageIndex];
        }
 
        MANDRILL_API VkFormat getImageFormat() const
        {
            return mImageFormat;
        }
 
        MANDRILL_API VkExtent2D getExtent() const
        {
            return mExtent;
        }
 
        MANDRILL_API uint32_t getImageIndex() const
        {
            return mImageIndex;
        }
 
        MANDRILL_API uint32_t getInFlightIndex() const
        {
            return mInFlightIndex;
        }
 
        MANDRILL_API uint32_t getPreviousInFlightIndex() const
        {
            return mPreviousInFlightIndex;
        }
 
        MANDRILL_API uint32_t getFramesInFlightCount() const
        {
            return static_cast<uint32_t>(mInFlightFences.size());
        }
 
        MANDRILL_API bool recreated() const
        {
            return mRecreated;
        }
 
    private:
        void querySupport();
        void createSwapchain();
        void destroySwapchain();
        void createSyncObjects(uint32_t framesInFlight);
        void destroySyncObjects();
        void createDescriptor();
        void destroyDescriptor();
 
        ptr<Device> mpDevice;
 
        VkSwapchainKHR mSwapchain;
        VkFormat mImageFormat;
        VkExtent2D mExtent;
 
        std::vector<VkImage> mImages;
        std::vector<VkImageView> mImageViews;
 
        struct {
            VkSurfaceCapabilitiesKHR capabilities{};
            std::vector<VkSurfaceFormatKHR> formats;
            std::vector<VkPresentModeKHR> presentModes;
        } mSupportDetails;
 
        std::vector<VkCommandBuffer> mCommandBuffers;
 
        std::vector<VkSemaphore> mRenderFinishedSemaphores;
        std::vector<VkSemaphore> mPresentFinishedSemaphores;
        std::vector<VkFence> mInFlightFences;
 
        uint32_t mInFlightIndex = 0;
        uint32_t mPreviousInFlightIndex = 0;
        uint32_t mImageIndex = 0;
 
        VkDescriptorSetLayout mDescriptorSetLayout;
        VkDescriptorPool mDescriptorPool;
        std::vector<VkDescriptorSet> mDescriptorSets;
 
        bool mRecreated = false;
 
        enum class ScreenshotState {
            Idle,
            Requested,
            QueuedForBlitting,
            BlittedToStage,
            CopiedToHost,
        };
 
        ScreenshotState mScreenshotState = ScreenshotState::Idle;
        ptr<Image> mScreenshotStageImage;
        std::mutex mScreenshotMutex;
        std::condition_variable mScreenshotAvailableCV;
        uint32_t mScreenshotInFlightIndex;
    };
} // namespace Mandrill