Application.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Core.hpp>
#include <Core/DefaultAllocator.hpp>
 
#include <Async/Future.hpp>
#include <Async/Thread.hpp>
#include <Native/Application.hpp>
 
#include <RHICore/Application.hpp>
#include <RHICore/Common.hpp>
#include <RenderCore/Renderer.hpp>
 
#include <Atomics/Atomic.hpp>
namespace Foundation::Rendering
{
    using namespace Core;
    using namespace RenderCore;
    struct ApplicationInitDesc
    {
        size_t deviceIndex{0};
        String windowTitle{"Application"};
        RHIExtent2D windowSize{800, 600};
        bool initOnResize{false};
        RendererDesc renderer {
            .enableAsyncCompute = true,
            .enablePresent = true,
            .numRenderThreads = std::max(1u, std::thread::hardware_concurrency() - 1)
        };
    };
    class RenderApplication : public Native::NativeApplication
    {
        void Execute();
        void CreateSwapchain();
        void InitializeInternal();
        void InitializeRenderer();
        void RenderWorker();
 
    public:
        struct FrameTiming
        {
            // [Frame Number, Perf Counter [ns]]
            using FTick = glm::vec<2, size_t>;
            // States
            FTick begin, delta;
            FTick Tick(FTick const& t)
            {
                if (t.x <= begin.x)
                {
                    begin = t; // Reset
                    return delta;
                }                    
                delta = t - begin;
                begin = t;
                return delta;
            }
            // Returns the average FPS over the last sample duration.
            [[nodiscard]] size_t GetFPS() const
            {
                if (delta.y == 0)
                    return 0;
                return static_cast<size_t>(1e9 * delta.x / delta.y);
            }
            const size_t kTimingSampleDuration{static_cast<size_t>(1.0 * 1e9) /* 1 second */};
        };
 
    protected:
        ApplicationInitDesc mDesc;
 
        DefaultAllocator mAlloc, mAllocRenderer;
        Native::NativeWindow mWindow;
        UniquePtr<RHIApplication> mRHI;
 
        RHIApplicationScopedObjectHandle<RHIDevice> mDevice;
        RHIDeviceScopedObjectHandle<RHISwapchain> mSwapchain;
 
        UniquePtr<Renderer> mRenderer;
        FrameTiming mTiming{};
        // The render thread. This is started in RunForever(),
        // and owns the Renderer instance and therefore all device resources.
        // Window events are also polled here - doing so on main thread seperately could make
        // @ref OnBeforeFrame and @ref OnAfterFrame usage difficult.
        Async::Thread mRenderThread;
        Async::Condition mRenderFrame;
        Async::Mutex mRenderMutex;
 
        // Should the Render thread reset the renderer on the next frame?
        bool mRenderThreadReset{false};
        // Has the Render thread started?
        bool mRenderThreadStarted{false};
        // Should the application exit?
        bool mAppShouldClose{false};
        virtual void OnDeviceSetup() { /* nop */ }
        virtual void OnBeforeFrame() { /* nop */ }
        virtual void OnAfterFrame() { /* nop */ }
        virtual void OnRendererSetup() = 0;
        virtual void OnRendererPostSetup() { /* nop */ }
        virtual void OnApplicationTick() { /* nop */ }
 
    public:
        template <typename Backend, typename... Args>
        void Initialize(ApplicationInitDesc const& desc = {}, Args&&... args)
        {
            // XXX: Backends are expected to take Allocator* as the first argument
            mDesc = desc;
            mRHI.reset();
            mRHI =
                ConstructUniqueBase<RHIApplication, Backend>(mAlloc.Ptr(), mAlloc.Ptr(), std::forward<Args>(args)...);
        }
        [[nodiscard]] RHIExtent2D GetFramebufferSize() const
        {
            auto [w, h] = mWindow.GetFramebufferSize();
            return {w, h};
        }
        [[nodiscard]] FrameTiming GetTiming() const { return mTiming; }
        [[nodiscard]] Renderer* GetRenderer() const { return mRenderer.get(); }
        [[nodiscard]] RHISwapchain* GetSwapchain() const
        {
            CHECK_MSG(mSwapchain, "No swapchain created. Did you initialize the application with present=true?");
            return mSwapchain.Get();
        }
        Native::NativeWindow* GetNativeWindow() { return &mWindow; }
        Allocator* GetAllocator() { return mAlloc.Ptr(); }
        Allocator* GetRendererAllocator() { return mAllocRenderer.Ptr(); }
        void RunForever();
        void WaitForFrame();
        void ResetRendererOnNextFrame();
        void Shutdown();
    };
} // namespace Foundation::Rendering