renderservice.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 "vk_mem_alloc.h"
#include "pipelinekey.h"
#include "renderutils.h"
 
// External Includes
#include <nap/service.h>
#include <windowevent.h>
#include <rendertarget.h>
#include <material.h>
#include <rect.h>
 
namespace nap
{
    // Forward Declares
    class CameraComponentInstance;
    class RenderableComponentInstance;
    class RenderWindow;
    class RenderService;
    class SceneService;
    class DescriptorSetCache;
    class DescriptorSetAllocator;
    class RenderableMesh;
    class IMesh;
    class MaterialInstance;
    class ComputeMaterialInstance;
    class ComputeComponentInstance;
    class Texture2D;
 
 
    // Render Service Configuration
 
    class NAPAPI RenderServiceConfiguration : public ServiceConfiguration
    {
        RTTI_ENABLE(ServiceConfiguration)
    public:
        enum class EPhysicalDeviceType : int
        {
            Integrated = 1, 
            Discrete = 2,   
            Virtual = 3,    
            CPU = 4         
        };
 
        bool                        mHeadless = false;                                              
        EPhysicalDeviceType         mPreferredGPU = EPhysicalDeviceType::Discrete;                  
        std::vector<std::string>    mLayers = { "VK_LAYER_KHRONOS_validation" };                    
        std::vector<std::string>    mAdditionalExtensions = { };                                    
        uint32                      mVulkanVersionMajor = 1;                                        
        uint32                      mVulkanVersionMinor = 0;                                        
        uint32                      mAnisotropicFilterSamples = 8;                                  
        bool                        mEnableHighDPIMode = true;                                      
        bool                        mEnableCompute = true;                                          
        bool                        mEnableCaching = true;                                          
        bool                        mEnableRobustBufferAccess = false;                              
        bool                        mPrintAvailableLayers = false;                                  
        bool                        mPrintAvailableExtensions = false;                              
 
        virtual rtti::TypeInfo      getServiceType() const override                                 { return RTTI_OF(RenderService); }
    };
 
 
    // Render Physical Device
 
    class NAPAPI PhysicalDevice final
    {
    public:
        // Default constructor, invalid object
        PhysicalDevice() = default;
 
        // Called by the render service
        PhysicalDevice(VkPhysicalDevice device, const VkPhysicalDeviceProperties& properties, const VkQueueFlags& queueCapabilities, int queueIndex);
 
        VkPhysicalDevice getHandle() const { return mDevice; }
 
        int getQueueIndex() const { return mQueueIndex; }
 
        const VkPhysicalDeviceProperties& getProperties() const { return mProperties; }
 
        const VkPhysicalDeviceFeatures& getFeatures() const { return mFeatures; }
 
        const VkQueueFlags& getQueueCapabilities() const { return mQueueCapabilities; }
 
        bool isValid() const { return mDevice != VK_NULL_HANDLE && mQueueIndex >= 0; }
 
    private:
        VkPhysicalDevice            mDevice = VK_NULL_HANDLE;           
        VkPhysicalDeviceProperties  mProperties;                        
        VkPhysicalDeviceFeatures    mFeatures;                          
        VkQueueFlags                mQueueCapabilities;                 
        int                         mQueueIndex = -1;                   
    };
 
 
    // Display
 
    class NAPAPI Display final
    {
    public:
        Display(int index);
 
        int getIndex() const { return mIndex; }
 
        float getDiagonalDPI() const { return mDDPI; }
 
        float getHorizontalDPI() const { return mHDPI; }
 
        float getVerticalDPI() const { return mVDPI; }
 
        const std::string& getName() const { return mName; }
 
        const glm::ivec2& getMin()  const { return mMin; }
 
        const glm::ivec2& getMax() const { return mMax; }
 
        math::Rect getBounds() const;
 
        bool isValid() const { return mValid; }
 
        std::string toString() const;
 
        bool operator== (const Display& rhs) const                          { return rhs.getIndex() == this->getIndex(); }
 
        bool operator!=(const Display& rhs) const                           { return !(rhs == *this); }
 
    private:
        std::string mName;                      
        int mIndex = -1;                        
        float mDDPI = 96.0f;                    
        float mHDPI = 96.0f;                    
        float mVDPI = 96.0f;                    
        glm::ivec2 mMin = { 0, 0 };             
        glm::ivec2 mMax = { 0, 0 };             
        bool mValid = false;                    
    };
    using DisplayList = std::vector<Display>;
 
 
    // Render Service
 
    class NAPAPI RenderService : public Service
    {
        friend class Texture2D;
        friend class GPUBuffer;
        friend class RenderWindow;
        RTTI_ENABLE(Service)
    public:
        using SortFunction = std::function<void(std::vector<RenderableComponentInstance*>&, const CameraComponentInstance&)>;
        using VulkanObjectDestructor = std::function<void(RenderService&)>;
        
        struct Pipeline
        {
            bool isValid() const    { return mPipeline != VK_NULL_HANDLE && mLayout != VK_NULL_HANDLE; }
 
            VkPipeline              mPipeline = VK_NULL_HANDLE;     
            VkPipelineLayout        mLayout = VK_NULL_HANDLE;       
        };
 
        RenderService(ServiceConfiguration* configuration);
 
        // Default destructor
        virtual ~RenderService();
 
        void beginFrame();
        
        void endFrame();
 
        bool beginHeadlessRecording();
        
        void endHeadlessRecording();
 
        bool beginRecording(RenderWindow& renderWindow);
        
        void endRecording();
 
        bool beginComputeRecording();
 
        void endComputeRecording();
 
        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera);
 
        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, const SortFunction& sortFunction);
 
        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, const std::vector<RenderableComponentInstance*>& comps);
 
        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, const std::vector<RenderableComponentInstance*>& comps, const SortFunction& sortFunction);
 
        void computeObjects(const std::vector<ComputeComponentInstance*>& comps);
 
        bool addWindow(RenderWindow& window, utility::ErrorState& errorState);
 
        void removeWindow(RenderWindow& window);
 
        RenderWindow* findWindow(void* nativeWindow) const;
 
        RenderWindow* findWindow(uint id) const;
 
        int getDisplayCount() const;
 
        const Display* findDisplay(int index) const;
 
        const Display* findDisplay(const nap::RenderWindow& window) const;
 
        const DisplayList& getDisplays() const;
 
        void addEvent(WindowEventPtr windowEvent);
 
        RenderableMesh createRenderableMesh(IMesh& mesh, MaterialInstance& materialInstance, utility::ErrorState& errorState);
 
        Pipeline getOrCreatePipeline(const IRenderTarget& renderTarget, const IMesh& mesh, const MaterialInstance& materialInstance, utility::ErrorState& errorState);
 
        Pipeline getOrCreateComputePipeline(const ComputeMaterialInstance& computeMaterialInstance, utility::ErrorState& errorState);
 
        Pipeline getOrCreatePipeline(const IRenderTarget& renderTarget, const RenderableMesh& renderableMesh, utility::ErrorState& errorState);
 
        void queueVulkanObjectDestructor(const VulkanObjectDestructor& function);
 
        DescriptorSetCache& getOrCreateDescriptorSetCache(VkDescriptorSetLayout layout);
 
        VmaAllocator getVulkanAllocator() const { return mVulkanAllocator; }
        
        bool isHeadless() const                                                     { return mHeadless; }
 
        VkCommandBuffer getCurrentCommandBuffer()                                   { assert(mCurrentCommandBuffer != VK_NULL_HANDLE); return mCurrentCommandBuffer; }
        
        RenderWindow* getCurrentRenderWindow()                                      { assert(mCurrentRenderWindow != VK_NULL_HANDLE); return mCurrentRenderWindow; }
 
        VkInstance getVulkanInstance() const                                        { return mInstance; }
 
        VkPhysicalDevice getPhysicalDevice() const                                  { return mPhysicalDevice.getHandle(); }
 
        const VkPhysicalDeviceFeatures& getPhysicalDeviceFeatures() const           { return mPhysicalDevice.getFeatures(); }
 
        uint32 getPhysicalDeviceVersion() const                                     { return mPhysicalDevice.getProperties().apiVersion; }
 
        const VkPhysicalDeviceProperties&   getPhysicalDeviceProperties() const     { return mPhysicalDevice.getProperties(); }
 
        VkDevice getDevice() const                                                  { return mDevice; }
 
        VkSampleCountFlagBits getMaxRasterizationSamples() const;
 
        bool getRasterizationSamples(ERasterizationSamples requestedSamples, VkSampleCountFlagBits& outSamples, nap::utility::ErrorState& errorState);
 
        bool sampleShadingSupported() const;
 
        bool anisotropicFilteringSupported() const;
 
        bool getWideLinesSupported() const                                          { return mWideLinesSupported; }
 
        bool getNonSolidFillSupported() const                                       { return mNonSolidFillModeSupported; }
 
        bool getPolygonModeSupported(EPolygonMode mode)                             { return mode == EPolygonMode::Fill || mNonSolidFillModeSupported; }
 
        bool getLargePointsSupported() const                                        { return mLargePointsSupported; }
 
        bool getHighDPIEnabled() const                                              { return mEnableHighDPIMode; }
 
        uint32 getAnisotropicSamples() const                                        { return mAnisotropicSamples; }
 
        VkFormat getDepthFormat() const                                             { return mDepthFormat; }
 
        VkCommandPool getCommandPool() const                                        { return mCommandPool; }
        
        VkImageAspectFlags getDepthAspectFlags() const;
        
        uint32 getQueueIndex() const                                                { return mPhysicalDevice.getQueueIndex(); }
        
        VkQueue getQueue() const                                                    { return mQueue; }
 
        bool isComputeAvailable() const;
 
        Texture2D& getEmptyTexture() const                                          { return *mEmptyTexture; }
 
        Material* getOrCreateMaterial(rtti::TypeInfo shaderType, utility::ErrorState& error);
 
        template<typename T>
        Material* getOrCreateMaterial(utility::ErrorState& error)                   { return getOrCreateMaterial(RTTI_OF(T), error); }
 
        int getCurrentFrameIndex() const                                            { return mCurrentFrameIndex; }
 
        int getMaxFramesInFlight() const                                            { return 2; }
 
        void getFormatProperties(VkFormat format, VkFormatProperties& outProperties);
 
        bool isRenderingFrame() const                                               { return mIsRenderingFrame; }
 
        uint32 getVulkanVersion() const                                             { return mAPIVersion; }
 
        uint32 getVulkanVersionMajor() const;
 
        uint32 getVulkanVersionMinor() const;
 
        nap::Signal<nap::RenderWindow&> windowAdded;
 
        nap::Signal<nap::RenderWindow&> windowRemoved;
 
        bool isInitialized() const  { return mInitialized; }
 
        void waitForFence(int frameIndex);
 
    protected:
        virtual void getDependentServices(std::vector<rtti::TypeInfo>& dependencies) override;
 
        virtual bool init(nap::utility::ErrorState& errorState) override;
 
        virtual void preShutdown() override;
 
        virtual void shutdown() override;
 
        virtual void preResourcesLoaded() override;
 
        virtual void postResourcesLoaded() override;
 
        virtual void update(double deltaTime) override;
 
    private:
        void sortObjects(std::vector<RenderableComponentInstance*>& comps, const CameraComponentInstance& camera);
 
        bool initEmptyTexture(nap::utility::ErrorState& errorState);
 
        void removeTextureRequests(Texture2D& texture);
 
        void requestTextureClear(Texture2D& texture);
 
        void requestTextureUpload(Texture2D& texture);
 
        void requestTextureDownload(Texture2D& texture);
 
        void requestBufferClear(GPUBuffer& buffer);
 
        void requestBufferUpload(GPUBuffer& buffer);
 
        void requestBufferDownload(GPUBuffer& buffer);
 
        void removeBufferRequests(GPUBuffer& buffer);
 
        void transferData(VkCommandBuffer commandBuffer, const std::function<void()>& transferFunction);
        
        void downloadData();
        
        void uploadData();
 
        void updateDownloads();
        
        void processVulkanDestructors(int frameIndex);
 
        void waitDeviceIdle();
 
        bool writeIni(const std::string& path, utility::ErrorState error);
 
        bool loadIni(const std::string& path, utility::ErrorState error);
 
        void restoreWindow(nap::RenderWindow& window);
 
    private:
        struct UniqueMaterial;
        using PipelineCache = std::unordered_map<PipelineKey, Pipeline>;
        using ComputePipelineCache = std::unordered_map<ComputePipelineKey, Pipeline>;
        using WindowList = std::vector<RenderWindow*>;
        using DescriptorSetCacheMap = std::unordered_map<VkDescriptorSetLayout, std::unique_ptr<DescriptorSetCache>>;
        using TextureSet = std::unordered_set<Texture2D*>;
        using BufferSet = std::unordered_set<GPUBuffer*>;
        using VulkanObjectDestructorList = std::vector<VulkanObjectDestructor>;
        using UniqueMaterialCache = std::unordered_map<rtti::TypeInfo, std::unique_ptr<UniqueMaterial>>;
 
        enum EQueueSubmitOp : uint
        {
            Rendering           = 0x01,                                             
            HeadlessRendering   = 0x02,                                             
            Compute             = 0x04                                              
        };
        using QueueSubmitOps = uint;
 
        struct Frame
        {
            VkFence                             mFence;                             
            std::vector<Texture2D*>             mTextureDownloads;                  
            std::vector<GPUBuffer*>         mBufferDownloads;                   
            VkCommandBuffer                     mUploadCommandBuffer;               
            VkCommandBuffer                     mDownloadCommandBuffer;             
            VkCommandBuffer                     mHeadlessCommandBuffer;             
            VkCommandBuffer                     mComputeCommandBuffer;              
            VulkanObjectDestructorList          mQueuedVulkanObjectDestructors;     
            QueueSubmitOps                      mQueueSubmitOps = 0U;               
        };
 
        struct UniqueMaterial
        {
            UniqueMaterial() = default;
            UniqueMaterial(std::unique_ptr<Shader> shader, std::unique_ptr<Material> material);
            std::unique_ptr<Shader>     mShader = nullptr;                  
            std::unique_ptr<Material>   mMaterial = nullptr;                
            bool valid() const;
        };
 
        bool                                    mEnableHighDPIMode = true;
        bool                                    mEnableCaching = true;
        bool                                    mSampleShadingSupported = false;
        bool                                    mAnisotropicFilteringSupported = false;
        bool                                    mWideLinesSupported = false;
        bool                                    mLargePointsSupported = false;
        bool                                    mNonSolidFillModeSupported = false;
        uint32                                  mAnisotropicSamples = 1;
        WindowList                              mWindows;
        DisplayList                             mDisplays;
        SceneService*                           mSceneService = nullptr;                                
        bool                                    mIsRenderingFrame = false;
        bool                                    mCanDestroyVulkanObjectsImmediately = true;
        std::unique_ptr<Texture2D>              mEmptyTexture;
 
        TextureSet                              mTexturesToClear;
        TextureSet                              mTexturesToUpload;
        BufferSet                               mBuffersToClear;
        BufferSet                               mBuffersToUpload;
 
        int                                     mCurrentFrameIndex = 0;
        std::vector<Frame>                      mFramesInFlight;
        RenderWindow*                           mCurrentRenderWindow = nullptr;
 
        DescriptorSetCacheMap                   mDescriptorSetCaches;
        std::unique_ptr<DescriptorSetAllocator> mDescriptorSetAllocator;
 
        VkInstance                              mInstance = VK_NULL_HANDLE;
        VmaAllocator                            mVulkanAllocator = VK_NULL_HANDLE;
        VkDebugReportCallbackEXT                mDebugCallback = VK_NULL_HANDLE;
        PhysicalDevice                          mPhysicalDevice;
        VkDevice                                mDevice = VK_NULL_HANDLE;
        VkCommandBuffer                         mCurrentCommandBuffer = VK_NULL_HANDLE;
 
        VkCommandPool                           mCommandPool = VK_NULL_HANDLE;
        VkQueue                                 mQueue = VK_NULL_HANDLE;
 
        PipelineCache                           mPipelineCache;
        ComputePipelineCache                    mComputePipelineCache;
 
        VkFormat                                mDepthFormat = VK_FORMAT_UNDEFINED;
        VkSampleCountFlagBits                   mMaxRasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
 
        uint32                                  mAPIVersion = 0;
        bool                                    mInitialized = false;
        bool                                    mSDLInitialized = false;
        bool                                    mShInitialized = false;
        bool                                    mHeadless = false;
 
        UniqueMaterialCache                     mMaterials;
 
        // Cache read from ini file, contains saved settings
        std::vector<std::unique_ptr<rtti::Object>> mCache;
    };
} // nap