NAP: renderwindow.h Source File

/* 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);


        virtual ~RenderWindow() override;


        virtual bool init(utility::ErrorState& errorState) override;


        virtual 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);


        virtual void setClearColor(const RGBAColorFloat& color) override;


        virtual const RGBAColorFloat& getClearColor() const override;


        void setPosition(const glm::ivec2& position);


        const glm::ivec2 getPosition() const;


        SDL_Window* getNativeWindow() const;


        virtual uint getNumber() const override;


        math::Rect getRect() const;


        math::Rect getRectPixels() const;


        virtual void beginRendering() override;


        virtual void endRendering() override;


        virtual VkFormat getColorFormat() const override                            { return mSwapchainFormat; }


        virtual VkFormat getDepthFormat() const override;


        virtual VkSampleCountFlagBits getSampleCount() const override               { return mRasterizationSamples; }


        virtual bool getSampleShadingEnabled() const override                       { return mSampleShadingEnabled; }


        virtual ECullWindingOrder getWindingOrder() const override;


        virtual VkRenderPass getRenderPass() const override                         { return mRenderPass; }


        bool                    mSampleShading      = true;

        int                     mWidth              = 512;

        int                     mHeight             = 512;

        bool                    mBorderless         = false;

        bool                    mResizable          = true;

        bool                    mVisible            = true;

        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                    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>        mImageAvailableSemaphores;

        std::vector<VkSemaphore>        mRenderFinishedSemaphores;

        std::vector<int>                mImagesInFlight;

        VkPresentModeKHR                mPresentationMode = VK_PRESENT_MODE_MAILBOX_KHR;

        ImageData                       mDepthImage;

        ImageData                       mColorImage;

        bool                            mSampleShadingEnabled = false;

        uint32                          mCurrentImageIndex = 0;

        uint32                          mSwapChainImageCount = 0;

        bool                            mRecreateSwapchain = false;

        VkSurfaceCapabilitiesKHR        mSurfaceCapabilities;

        VkExtent2D                      mSwapchainExtent = {0,0};


        VkCommandBuffer beginRecording();


        void endRecording();


        void handleEvent(const Event& event);


        bool getSurfaceCapabilities(utility::ErrorState& error);


        bool recreateSwapChain(utility::ErrorState& errorState);


        bool createSwapChainResources(utility::ErrorState& errorState);


        void destroySwapChainResources();


        bool validSwapchainExtent() const;

    };

}