RV_VKSwapchain.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RV_VKSwapchain.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Class to manage Vulkan swapchain object
 */
#ifndef RV_VKSwapchain_h
#define RV_VKSwapchain_h

#include <VE/VE_VK.h>

#ifdef VULKAN_PRESENTATION

#include "RV_API.h"
#include "RV_TypePtrs.h"

#include <VE/VE_VK.h>

#include <UT/UT_Array.h>
#include <UT/UT_UniquePtr.h>

class RV_VKSurface;
class RV_Render;

class RV_API RV_VKSwapchainCreateInfo
{
public:
    exint getWidth() const
        { return myVkCreateInfo.imageExtent.width; }
    exint getHeight() const
        { return myVkCreateInfo.imageExtent.height; }
    VkFormat getImageFormat() const
        { return myVkCreateInfo.imageFormat; } 

    void setSurface(RV_VKSurface* surface);
    void setMinImgCount(exint img_count);
    void setFormat(VkSurfaceFormatKHR surface_format);
    void setSize(exint width, exint height);
    void setQueueFamilies(const UT_Array<uint32_t>* queue_family_indices);
    void setPresentMode(VkPresentModeKHR mode);
    void setOldSwapchain(RV_VKSwapchain* old_sc);
    void setUsage(VkImageUsageFlags usage)
        { myVkCreateInfo.imageUsage = usage; }
    void setPreTransform(VkSurfaceTransformFlagBitsKHR transform)
        { myVkCreateInfo.preTransform = transform; }
    void setClipped(bool clipped)
        { myVkCreateInfo.clipped = clipped; }

    RV_VKSwapchainCreateInfo() = default;
    UT_UniquePtr<RV_VKSwapchainCreateInfo> clone() const
    {
        return UT_UniquePtr<RV_VKSwapchainCreateInfo>(
                    new RV_VKSwapchainCreateInfo(*this));
    }

protected:
    VkSwapchainCreateInfoKHR myVkCreateInfo = {
        VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
        nullptr,
        0,                                     /* flags */
        VK_NULL_HANDLE,                        /* surface */
        2,                                     /* minImageCount */
        VK_FORMAT_B8G8R8A8_SRGB,               /* imageFormat */
        VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,     /* imageColorSpace */
        { 0, 0 },                              /* imageExtent */
        1,                                     /* imageArrayLayers */
        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,   /* imageUsage */
        VK_SHARING_MODE_EXCLUSIVE,             /* imageSharingMode */
        0,                                     /* queueFamilyIndexCount */
        nullptr,                               /* pQueueFamilyIndices */
        VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, /* preTransform */
        VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,     /* compositeAlpha */
        VK_PRESENT_MODE_MAILBOX_KHR,           /* presentMode */
        VK_TRUE,                               /* clipped */
        VK_NULL_HANDLE                         /* oldSwapchain */
    };

    RV_VKSurface* mySurface;

    RV_VKSwapchainCreateInfo(const RV_VKSwapchainCreateInfo&) = default;
    RV_VKSwapchainCreateInfo &operator=(const RV_VKSwapchainCreateInfo&) = delete;

    friend class RV_VKSwapchain;
};

class RV_API RV_VKSwapchain
{
public:
    static RV_VKSwapchainPtr create(
        RV_Instance* inst,
        const RV_VKSwapchainCreateInfo* info);

    RV_VKSwapchain(
        RV_Instance* inst,
        const RV_VKSwapchainCreateInfo* info,
        VkSwapchainKHR vk_sc);

    ~RV_VKSwapchain();

    void            initialize(RV_Render* r);
    bool            isInitialized() const
        { return myImageCount; }

    void            nextImage();
    void            prepareForPresent(RV_Render* r);

    VkSwapchainKHR  getVkSwapchain() const
        { return myVkSwapchain; }
    uint32_t        getCurrentImageIndex() const
        { return myImageIndex; }
    RV_VKImage*     getCurrentImage() const
        { return myImages(myImageIndex).get(); }
    RV_Framebuffer* getCurrentFramebuffer() const
        { return myFramebuffers(myImageIndex).get(); }
    VkSemaphore     getCurrentImageAcquiredSem() const
        { return myImageAcquiredSems(myFrameIndex); }
    VkSemaphore     getCurrentPresentReadySem() const
        { return myPresentReadySems(myFrameIndex); }

    UT_NON_COPYABLE(RV_VKSwapchain);

private:
    RV_Instance* myInst;
    VkSwapchainKHR myVkSwapchain;
    UT_UniquePtr<const RV_VKSwapchainCreateInfo> myInfo;

    UT_Array<RV_VKImagePtr> myImages;
    UT_Array<RV_VKFramebufferPtr> myFramebuffers;
    UT_Array<VkSemaphore> myImageAcquiredSems;
    UT_Array<VkSemaphore> myPresentReadySems;
    uint32_t myImageCount = 0;
    uint32_t myFrameIndex = 0;
    uint32_t myImageIndex = 0;
};

#endif // VULKAN_PRESENTATION

#endif