NAP: renderservice.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 "vk_mem_alloc.h"

#include "pipelinekey.h"

#include "renderutils.h"

#include "imagedata.h"

#include "rendertag.h"


// External Includes

#include <nap/service.h>

#include <windowevent.h>

#include <rendertarget.h>

#include <material.h>

#include <rect.h>

#include <color.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 Texture;

    class Texture2D;

    class RenderLayer;

    class RenderChain;


    // Render Service Configuration


    class NAPAPI RenderServiceConfiguration : public ServiceConfiguration

    {

        RTTI_ENABLE(ServiceConfiguration)

    public:

        enum class EPhysicalDeviceType : int

        {

            Discrete    = 4,

            Integrated  = 3,

            CPU         = 2,

            Virtual     = 1,

            Other       = 0

        };


        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                            mEnableDebug = 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 Texture;

        friend class Texture2D;

        friend class GPUBuffer;

        friend class RenderWindow;

        friend class RenderTag;

        friend class RenderChain;


        RTTI_ENABLE(Service)

    public:

        using SortFunction = std::function<void(std::vector<RenderableComponentInstance*>&, const glm::mat4& viewMatrix)>;

        using VulkanObjectDestructor = std::function<void(RenderService&)>;

        using RenderCommand = 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();


        void queueHeadlessCommand(const RenderCommand& command);


        void queueComputeCommand(const RenderCommand& command);


        bool beginRecording(RenderWindow& renderWindow);


        void endRecording();


        bool beginComputeRecording();


        void endComputeRecording();


        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, RenderMask renderMask = mask::all);


        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, const SortFunction& sortFunction, RenderMask = mask::all);


        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, const std::vector<RenderableComponentInstance*>& comps, RenderMask renderMask = mask::all);


        void renderObjects(IRenderTarget& renderTarget, CameraComponentInstance& camera, const std::vector<RenderableComponentInstance*>& comps, const SortFunction& sortFunction, RenderMask renderMask = mask::all);


        void renderObjects(IRenderTarget& renderTarget, const glm::mat4& projection, const glm::mat4& view, const std::vector<RenderableComponentInstance*>& comps, const SortFunction& sortFunction, RenderMask renderMask = mask::all);


        void computeObjects(const std::vector<ComputeComponentInstance*>& comps);


        std::vector<RenderableComponentInstance*> filterObjects(const std::vector<RenderableComponentInstance*>& comps, RenderMask renderMask);


        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 isHeadlessCommandQueued() const                                        { return !mHeadlessCommandQueue.empty(); }


        bool isComputeCommandQueued() const                                         { return !mComputeCommandQueue.empty(); }


        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;


        glm::uvec3 getMaxComputeWorkGroupSize() 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& getEmptyTexture2D() const                                        { return *mEmptyTexture2D; }


        TextureCube& getEmptyTextureCube() const                                    { return *mEmptyTextureCube; }


        Texture2D& getErrorTexture2D() const                                        { return *mErrorTexture2D; }


        TextureCube& getErrorTextureCube() const                                    { return *mErrorTextureCube; }


        RenderMask getRenderMask(const RenderTag& renderTag) const;


        RenderMask getRenderMask(const std::string& tagName);


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


        bool isRenderingFrame() const                                               { return mIsRenderingFrame; }


        uint32 getVulkanVersion() const                                             { return mAPIVersion; }


        uint32 getVulkanVersionMajor() const;


        uint32 getVulkanVersionMinor() const;


        bool initShaderCompilation(utility::ErrorState& error);


        nap::Signal<nap::RenderWindow&> windowAdded;


        nap::Signal<nap::RenderWindow&> windowRemoved;


        bool isInitialized() const                                                  { return mInitialized; }


        void waitForFence(int frameIndex);


        int getRank(const nap::RenderLayer& layer) const;


    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:

        bool initEmptyTextures(nap::utility::ErrorState& errorState);


        void removeTextureRequests(Texture2D& texture);


        void requestTextureClear(Texture& 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);


        bool addTag(const RenderTag& renderTag, nap::utility::ErrorState& error);


        void removeTag(const RenderTag& renderTag);


        void addChain(const RenderChain& chain);


        void removeChain(const RenderChain& chain);


    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<Texture*>;

        using Texture2DSet = 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;


        // Empty textures

        std::unique_ptr<Texture2D>              mEmptyTexture2D;

        std::unique_ptr<TextureCube>            mEmptyTextureCube;


        // Error textures

        std::unique_ptr<Texture2D>              mErrorTexture2D;

        std::unique_ptr<TextureCube>            mErrorTextureCube;

        const RGBAColorFloat                    mErrorColor = { 1.0f, 0.3137f, 0.3137f, 1.0f };


        TextureSet                              mTexturesToClear;

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

        VkDebugUtilsMessengerEXT                mDebugUtilsMessengerCallback = 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;


        // Render command queues

        std::vector<RenderCommand>              mHeadlessCommandQueue;

        std::vector<RenderCommand>              mComputeCommandQueue;


        // The registered render tag and layer registries

        std::vector<const RenderTag*>           mRenderTags;


        // Cache read from ini file, contains saved settings

        std::vector<std::unique_ptr<rtti::Object>> mCache;


        // Render chains

        std::vector<const RenderChain*> mRenderChains;

    };

} // nap