renderwindow.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "renderutils.h"
#include "irendertarget.h"
 
// External Includes
#include <window.h>
#include <rect.h>
 
// SDL Forward declares
struct SDL_Window;
 
namespace nap
{
    // Forward Declares
    class Core;
    class RenderService;
 
    class NAPAPI RenderWindow : public Window, public IRenderTarget
    {
        RTTI_ENABLE(Window)
        friend class RenderService;
    public:
        enum class EPresentationMode : int
        {
            Immediate,                  
            Mailbox,                    
            FIFO_Relaxed,               
            FIFO                        
        };
 
        RenderWindow(Core& core);
 
        RenderWindow(Core& core, SDL_Window* windowHandle);
 
        ~RenderWindow() override;
 
        bool init(utility::ErrorState& errorState) override;
 
        void onDestroy() override;
 
        const glm::ivec2 getSize() const;
 
        int getWidth() const                                                    { return getSize().x; }
 
        int getWidthPixels() const                                              { return getBufferSize().x; }
        
        int getHeight() const                                                   { return getSize().y; }
        
        int getHeightPixels() const                                             { return getBufferSize().y; }
        
        const glm::ivec2 getBufferSize() const override;
 
        void show();
 
        void hide();
 
        const std::string& getTitle() const                                     { return mTitle; }
 
        void setTitle(std::string newTitle);
 
        bool isResizable() const                                                { return mResizable; }
    
        void setFullscreen(bool value);
 
        void toggleFullscreen();
 
        void setWidth(int width);
 
        void setHeight(int height);
 
        void setSize(const glm::ivec2& size);
 
        void setClearColor(const RGBAColorFloat& color) override;
 
        const RGBAColorFloat& getClearColor() const override;
 
        void setPosition(const glm::ivec2& position) const;
 
        glm::ivec2 getPosition() const;
 
        float getPixelDensity() const;
 
        float getDisplayScale() const;
 
        void setAlwaysOnTop(bool onTop);
 
        SDL_Window* getNativeWindow() const;
 
        bool isEmbedded() const                                                 { return mExternalHandle != nullptr; }
 
        bool isMinimized() const;
 
        bool isHidden() const;
 
        bool isOccluded() const;
 
        uint getNumber() const override;
 
        math::Rect getRect() const;
 
        math::Rect getRectPixels() const;
 
        inline float getRatio() const                                               { return static_cast<float>(getBufferSize().y) / static_cast<float>(getBufferSize().x); }
 
        void beginRendering() override;
 
        void endRendering() override;
 
        VkFormat getColorFormat() const override                            { return mSwapchainFormat; }
 
        VkFormat getDepthFormat() const override;
        
        VkSampleCountFlagBits getSampleCount() const override               { return mRasterizationSamples; }
        
        bool getSampleShadingEnabled() const override                       { return mSampleShadingEnabled; }
 
        ECullWindingOrder getWindingOrder() const override;
 
        VkRenderPass getRenderPass() const override                         { return mRenderPass; }
 
        VkImageLayout getFinalLayout() const override                       { return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; }
 
        int getDisplayIndex() const;
 
        bool                    mSampleShading      = true;                             
        int                     mWidth              = 512;                              
        int                     mHeight             = 512;                              
        bool                    mBorderless         = false;                            
        bool                    mResizable          = true;                             
        bool                    mVisible            = true;                             
        bool                    mAlwaysOnTop        = false;                            
        EPresentationMode       mMode               = EPresentationMode::Immediate;     
        std::string             mTitle              = "";                               
        RGBAColorFloat          mClearColor         = { 0.0f, 0.0f, 0.0f, 1.0f };       
        ERasterizationSamples   mRequestedSamples   = ERasterizationSamples::Four;      
        int                     mAddedSwapImages    = 1;                                
        bool                    mClear              = true;                             
        bool                    mRestorePosition    = true;                             
        bool                    mRestoreSize        = true;                             
 
    private:
        RenderService*                  mRenderService  = nullptr;
        SDL_Window*                     mSDLWindow      = nullptr;                      
        VkSampleCountFlagBits           mRasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
        VkDevice                        mDevice = VK_NULL_HANDLE;
        VkSurfaceKHR                    mSurface = VK_NULL_HANDLE;
        VkSwapchainKHR                  mSwapchain = VK_NULL_HANDLE;
        VkRenderPass                    mRenderPass = VK_NULL_HANDLE;
        VkQueue                         mPresentQueue = VK_NULL_HANDLE;
        VkFormat                        mSwapchainFormat = VK_FORMAT_UNDEFINED;
        std::vector<VkImageView>        mSwapChainImageViews;
        std::vector<VkFramebuffer>      mSwapChainFramebuffers;
        std::vector<VkCommandBuffer>    mCommandBuffers;
        std::vector<VkSemaphore>        mAcquireSemaphores;
        std::vector<VkSemaphore>        mSubmitSemaphores;
        VkPresentModeKHR                mPresentationMode = VK_PRESENT_MODE_MAILBOX_KHR;
        ImageData                       mDepthImage;
        ImageData                       mColorImage;
        bool                            mSampleShadingEnabled = false;
        uint32                          mImageIndex = 0;
        bool                            mRecreateSwapchain = false;
        VkSurfaceCapabilitiesKHR        mSurfaceCapabilities;
        VkExtent2D                      mSwapchainExtent = {0,0};
        SDL_Window*                     mExternalHandle = nullptr;
 
        VkCommandBuffer beginRecording();
 
        void endRecording();
 
        bool getSurfaceCapabilities(utility::ErrorState& error);
 
        bool recreateSwapChain(utility::ErrorState& errorState);
        
        bool createSwapChainResources(utility::ErrorState& errorState);
 
        void destroySwapChainResources();
 
        bool validSwapchainExtent() const;
    };
}