foray_defaultappbase.hpp

Go to the documentation of this file.

#pragma once
#include "../bench/foray_hostbenchmark.hpp"
#include "../core/foray_samplercollection.hpp"
#include "../core/foray_shadermanager.hpp"
#include "../foray_vma.hpp"
#include "../osi/foray_osmanager.hpp"
#include "../stages/foray_stages_declares.hpp"
#include "foray_framerenderinfo.hpp"
#include "foray_renderloop.hpp"
#include "foray_vulkandevice.hpp"
#include "foray_vulkaninstance.hpp"
#include "foray_vulkanwindowswapchain.hpp"
#include <array>
#include <vector>
 
namespace foray::base {
 
    class DefaultAppBase
    {
      public:
        DefaultAppBase();
        virtual ~DefaultAppBase() = default;
 
        FORAY_GETTER_MR(RenderLoop)
        FORAY_GETTER_MR(OsManager)
        FORAY_GETTER_MR(Instance)
        FORAY_GETTER_MR(Device)
        FORAY_GETTER_MR(WindowSwapchain)
        FORAY_GETTER_MR(HostFrameRecordBenchmark)
 
        
        int32_t Run();
 
      protected:
        inline virtual void ApiBeforeInit() {}
 
        inline virtual void ApiBeforeWindowCreate(osi::Window& window) {}
        inline virtual void ApiBeforeInstanceCreate(vkb::InstanceBuilder& instanceBuilder) {}
        inline virtual void ApiBeforeDeviceSelection(vkb::PhysicalDeviceSelector& pds) {}
        inline virtual void ApiBeforeDeviceBuilding(vkb::DeviceBuilder& deviceBuilder) {}
        inline virtual void ApiBeforeSwapchainBuilding(vkb::SwapchainBuilder& swapchainBuilder) {}
        inline virtual void ApiInit() {}
        inline virtual void ApiOnResized(VkExtent2D size) {}
        inline virtual void ApiOnEvent(const osi::Event* event) {}
        inline virtual void ApiRender(FrameRenderInfo& renderInfo) {}
        inline virtual void ApiFrameFinishedExecuting(uint64_t frameIndex) {}
        inline virtual void ApiOnShadersRecompiled(std::unordered_set<uint64_t>& recompiledShaderKeys) {}
        inline virtual void ApiDestroy() {}
 
        virtual void RegisterRenderStage(stages::RenderStage* stage);
        virtual void UnregisterRenderStage(stages::RenderStage* stage);
 
        virtual void Init();
        virtual void InitGetQueue();
        virtual void InitCommandPool();
        virtual void InitCreateVma();
        virtual void InitSyncObjects();
 
        virtual void RecreateSwapchain();
        inline void OnResized(VkExtent2D size);
 
        virtual void PollEvents();
 
        virtual bool CanRenderNextFrame();
        virtual void Render(RenderLoop::RenderInfo& renderInfo);
        virtual void OnShadersRecompiled(std::unordered_set<uint64_t>& recompiledShaderKeys);
 
        virtual void Destroy();
 
        RenderLoop              mRenderLoop;
        osi::OsManager          mOsManager;
        VulkanInstance          mInstance;
        VulkanDevice            mDevice;
        VulkanWindowSwapchain   mWindowSwapchain;
        core::SamplerCollection mSamplerCollection;
        core::Context           mContext;
        core::ShaderManager     mShaderManager;
 
        uint32_t                                        mAuxiliaryCommandBufferCount = 0;
        std::array<InFlightFrame, INFLIGHT_FRAME_COUNT> mInFlightFrames;
        uint32_t                                        mInFlightFrameIndex = 0;
        uint64_t                                        mRenderedFrameCount = 0;
 
        std::vector<stages::RenderStage*> mRegisteredStages;
 
        fp64_t mLastShadersCheckedTimestamp = 0.0;
 
        inline static const char* const FRAMERECORDBENCH_WAITONFENCE      = "Wait On Fence";
        inline static const char* const FRAMERECORDBENCH_ACQUIRESWAPIMAGE = "Acquire Swapimage";
        inline static const char* const FRAMERECORDBENCH_RECORDCMDBUFFERS = "Record CmdBuffers";
        inline static const char* const FRAMERECORDBENCH_PRESENT          = "Present";
 
        bool                 mEnableFrameRecordBenchmark = false;
        bench::HostBenchmark mHostFrameRecordBenchmark;
    };
}  // namespace foray::base