VulkanRenderPipeline.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Graphics
File: VulkanRenderPipeline
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "VulkanDefines.h"
#include "VulkanImage.h"
#include "VulkanRenderDefinition.h"
#include "ImageResources.h"
 
#include "NDEVRGraphics/Headers/GraphicsPipeline.h"
#include "Base/Headers/String.h"
#include "Base/Headers/Pointer.hpp"
#include "Base/Headers/Buffer.hpp"
namespace NDEVR
{
    struct SwapChainSupportDetails;
    class File;
    class Log;
    class WindowInstance;
    class VulkanSession;
    class GraphicsUpdateArguments;
    class VulkanRenderDefinition;
    struct SwapChainSupportDetails;
 
    class VulkanRenderPipeline : public GraphicsPipeline
    {
    protected:
        struct SwapChainSupportDetails
        {
            VkSurfaceCapabilitiesKHR capabilities = {};
            Buffer<VkSurfaceFormatKHR, uint04, ObjectAllocator<true>> formats;
            Buffer<VkPresentModeKHR> presentModes;
        };
    protected:
        struct FrameResources
        {
            VkFence fence = vk_null;
            VkSemaphore image_sem = vk_null;
            VkSemaphore draw_sem = vk_null;
            ImageResources* image_acquired = nullptr;
            bool image_sem_waitable = false;
            bool fence_waitable = false;
        };
    public:
        VulkanRenderPipeline(VulkanSession* session);
        VulkanRenderPipeline(VulkanRenderPipeline&& pipeline);
        VulkanRenderPipeline(const VulkanRenderPipeline& pipeline) = delete;
        virtual ~VulkanRenderPipeline();
        void cleanResources() override;
        void setDevice(const DynamicPointer<VulkanDevice>& instance);
        void init(GraphicsUpdateArguments& args) override;
        void setWindowInstance(WindowInstance* instance) override;
        void cleanup() override;
        void getKHRImage(GraphicsUpdateArguments& args);
        void getGrabImage(GraphicsUpdateArguments& args);
        bool runCommand(GraphicsUpdateArguments& args) override;
        virtual void drawFrame(GraphicsUpdateArguments& args) override;
        virtual bool needsRecreateSwapchain(GraphicsUpdateArguments& args);
        virtual bool executeDrawCycle(GraphicsUpdateArguments& args);
        void invalidateImages();
        virtual void submitQueue(GraphicsUpdateArguments& args);
        void presentKHR(GraphicsUpdateArguments& args);
        //void setSession(const DynamicPointer<VulkanSession>& session);
        bool createPipeline(GraphicsUpdateArguments& args) override;
        void requestRedraw();
        void setSwapChainImageFormat(VkFormat format);
        DynamicPointer<VulkanRenderDefinition>& getRenderDefinition();
        void setupSwapChainImages(Buffer<VkImage>& images, uint04 multisample_count);
 
        virtual const ConstPointer<GraphicsDevice>& device() const override;
        const DynamicPointer<GraphicsDevice>& device() override;
        void setGrabImage(Image* image);
        void imageWait();
        void setClearColor(const RGBColor& color);
        void ensureLastRenderComplete() override;
    protected:
        void addReadback(GraphicsUpdateArguments& args);
        VkResult finishBlockingReadback(GraphicsUpdateArguments& args);
        virtual void cleanupSwapChainResources(bool clean_khr);
        virtual void cleanupKHR();
        virtual void recreateSwapChainResources(GraphicsUpdateArguments& args);
        void setShadowImages(GraphicsUpdateArguments& args);
        void setViewportImages(GraphicsUpdateArguments& args);
        void setMultisampleImages(GraphicsUpdateArguments& args);
        bool neadsSurfaceUpdate() const;
        void setupSurface();
        virtual void getKHRImages(uint04 multisample_count);
        void getGrabImages(uint04 multisample_count);
        void createFrames();
        virtual void lockAllImagesCommand();
        static fltp08 ScreenSizeAllocationFactor();
        void lockImageCommand(ImageResources& image) const;
        [[nodiscard]] Buffer<VkClearValue, uint04, ObjectAllocator<true>> clearValues() const;
        SwapChainSupportDetails queryKHRSupport(VkPhysicalDevice_T* device);
        VkSurfaceFormatKHR chooseSwapSurfaceFormat(const Buffer<VkSurfaceFormatKHR, uint04, ObjectAllocator<true>>& availableFormats);
        Vector<2, uint04> chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, const Vector<2, uint04>& requested_size);
 
        bool needsCleanup() const { return m_needs_cleanup; }
        virtual void createSwapChainKHR(GraphicsUpdateArguments& args);
        void createCommandBuffers();
 
        virtual void commit(GraphicsUpdateArguments&) override {};
        virtual void updateUniformBuffer(GraphicsUpdateArguments&) override {};
        virtual bool hasCommand() const override { return false; };
    protected:
        void updateFrameSize(GraphicsUpdateArguments& args);
    protected:
        VkSurfaceKHR m_surface;
        VkSwapchainKHR m_khr_swap_chain;
 
        Buffer<FrameResources> m_frames;
        Buffer<ImageResources> m_khr_images;
        Buffer<ImageResources> m_grab_images;
 
        DynamicPointer<VulkanImageData> m_frame_grab_image;
        DynamicPointer<VulkanImageData> m_multisample_image_color;
        DynamicPointer<VulkanImageView> m_multisample_view_color;
        DynamicPointer<VulkanImageData> m_depth_image;
        DynamicPointer<VulkanImageView> m_depth_view;
        DynamicPointer<VulkanImageData> m_shadow_image;
        DynamicPointer<VulkanImageView> m_shadow_view;
 
        DynamicPointer<VulkanDevice> m_device;
        VulkanSession* m_session;
        DynamicPointer<VulkanRenderDefinition> m_render_definition;
        ConstPointer<SwapChainSupportDetails> m_swap_chain_support_details;
 
        WindowInstance* m_window_instance;
        ImageResources* m_last_image;
        Image* m_grab_image;
 
        Vector<2, uint04> m_draw_size;
        Time m_last_render_time;
        Time m_surface_update_time;
        uint08 m_khr_format;
        uint04 m_number_of_grab_images;
        
        RGBColor m_clear_color;
        bool m_needs_grab_image;
        bool m_needs_screen_draw;
        bool m_is_init;
        bool m_needs_pipeline_recreation;
        bool m_needs_cleanup;
        bool m_suboptimal_khr;
        
    };
}