VulkanRenderPipeline.h

/*--------------------------------------------------------------------------------------------
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 PipelineSemaphore
        {
            VkSemaphore semaphore = vk_null;    
            bool is_active = false;             
        };

        struct PipelineSemaphores
        {
            PipelineSemaphore acquire;  
            PipelineSemaphore finished; 
        };

        struct SwapChainSupportDetails
        {
            VkSurfaceCapabilitiesKHR capabilities = {};         
            PrimitiveBuffer<VkSurfaceFormatKHR> formats;        
            PrimitiveBuffer<VkPresentModeKHR> presentModes;     
        };
    public:
        VulkanRenderPipeline(VulkanSession* session);
        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 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 ensureFinished(uint04 frame_index);
        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 needsSurfaceUpdate() const;
        void setupSurface();
        virtual void createKHRImages(uint04 multisample_count);
        void createGrabImages(uint04 multisample_count);
        static fltp08 ScreenSizeAllocationFactor();
        [[nodiscard]] PrimitiveBuffer<VkClearValue> clearValues() const;
        SwapChainSupportDetails queryKHRSupport(VkPhysicalDevice_T* device);
        VkSurfaceFormatKHR chooseSwapSurfaceFormat(const PrimitiveBuffer<VkSurfaceFormatKHR>& availableFormats);
        Vector<2, uint04> chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, const Vector<2, uint04>& requested_size);
 
        bool needsCleanup() const { return m_needs_cleanup; }
        virtual bool createSwapChainKHR(GraphicsUpdateArguments& args);
        void createCommandBuffers();
 
        virtual void commit(GraphicsUpdateArguments&) override {};
        virtual void updateUniformBuffer(GraphicsUpdateArguments&) override {};
        virtual bool hasCommand() const override { return false; };
    protected:
        bool updateFrameSize(GraphicsUpdateArguments& args);
    protected:
        VkSurfaceKHR m_surface;                                 
        VkSwapchainKHR m_khr_swap_chain;                        
        Buffer<PipelineSemaphores> m_semaphores;                
        Buffer<VulkanImageResources> m_frames;                  
        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;                      
        uint04 m_last_image_idx;                                
        Image* m_grab_image;                                    
        VkQueue_T* m_present_queue = vk_null;                   
        Vector<2, uint04> m_draw_size;                          
        Time m_surface_update_time;                             
        uint08 m_khr_format;                                    
        uint04 m_number_of_grab_images = 0;                     
        uint04 m_number_of_khr_images = 0;                      
        uint04 m_pipeline_acquire = 0;                          
        RGBColor m_clear_color;                                 
        bool m_needs_grab_image;                                
        bool m_is_init;                                         
        bool m_needs_pipeline_recreation;                       
        bool m_needs_cleanup;                                   
        bool m_suboptimal_khr;                                  
        
    };
}