src/VulkanSwapChain.hpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

/*
* Class wrapping access to the swap chain
*
* A swap chain is a collection of framebuffers used for rendering and presentation to the windowing system
*
* Copyright (C) 2016-2017 by Sascha Willems - www.saschawillems.de
*
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/

#pragma once

#include "vke.hpp"

namespace vke {

    typedef struct _SwapChainBuffers {
        VkImage image;
        VkImageView view;
    } SwapChainBuffer;

    class swap_chain_t
    {
    private:
        // Function pointers
        PFN_vkGetPhysicalDeviceSurfaceSupportKHR        fpGetPhysicalDeviceSurfaceSupportKHR;
        PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR   fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
        PFN_vkGetPhysicalDeviceSurfaceFormatsKHR        fpGetPhysicalDeviceSurfaceFormatsKHR;
        PFN_vkGetPhysicalDeviceSurfacePresentModesKHR   fpGetPhysicalDeviceSurfacePresentModesKHR;
        PFN_vkCreateSwapchainKHR    fpCreateSwapchainKHR;
        PFN_vkDestroySwapchainKHR   fpDestroySwapchainKHR;
        PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
        PFN_vkAcquireNextImageKHR   fpAcquireNextImageKHR;
        PFN_vkQueuePresentKHR       fpQueuePresentKHR;
    public:
        engine_t*                   vke;
        VkSwapchainCreateInfoKHR    infos = {VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR};

        VkSwapchainKHR              swapChain = VK_NULL_HANDLE;

        uint32_t                    imageCount;
        std::vector<SwapChainBuffer>buffers;
        uint32_t                    currentBuffer = 0;
        VkSemaphore                 presentCompleteSemaphore;
        VkPresentInfoKHR            presentInfo;
        VkFormat                    depthFormat;

        std::vector<render_target_t*>  boundRenderTargets;

        //RenderTarget* multisampleTarget;
        Texture* depthStencil;

        swap_chain_t(engine_t* _vke, bool vsync = true);
        virtual ~swap_chain_t();

        void create(uint32_t& width, uint32_t& height);

        inline VkResult acquireNextImage(VkDevice dev) {
            return fpAcquireNextImageKHR(dev, swapChain, UINT64_MAX,
                                         presentCompleteSemaphore, (VkFence)nullptr, &currentBuffer);
        }
        inline VkResult queuePresent(VkQueue queue, VkSemaphore waitSemaphore = VK_NULL_HANDLE) {
            presentInfo.pImageIndices = &currentBuffer;
            presentInfo.pWaitSemaphores = &waitSemaphore;

            if (waitSemaphore == VK_NULL_HANDLE)
                presentInfo.waitSemaphoreCount = 0;
            else
                presentInfo.waitSemaphoreCount = 1;

            return fpQueuePresentKHR(queue, &presentInfo);
        }
    };

}