UIWindowDevice.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/RenderAPI/Forward.hpp"
#include "Forward.hpp"
#include "CeresEngine/Renderer/Forward.hpp"
#include "CeresEngine/Platform/Forward.hpp"
#include "UIEvent.hpp"
#include "UIBackingStore.hpp"
#include "UIUtility.hpp"
#include "UIWindow.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Container/Array.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Graphics/GraphicsRenderer.hpp"
#include "CeresEngine/Input/InputEvent.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine {
 
    class UIWindowDevice : public RefCounted<UIWindowDevice> {
        friend class UIWindow;
 
    public:
        explicit UIWindowDevice() noexcept = default;
        virtual ~UIWindowDevice() noexcept = default;
 
    public: // Drawing
        virtual void draw(UIBackingStore& backingStore, UIDrawCommandBuffer& commandBuffer);
 
        virtual void flush(UIWindow& window, UIBackingStore& backingStore);
 
        [[nodiscard]] virtual UIBackingStorePtr createBackingStore(UIWindow& window) = 0;
 
        [[nodiscard]] virtual double getBackingScaleFactor(const UIWindow& window) const { return 1.0; }
 
    public: // Window management
        [[nodiscard]] virtual UIBackingStorePtr registerWindow(UIWindow& window);
 
        virtual void unregisterWindow(UIWindow& window);
 
    protected:
        void notifyFrameChanged(UIWindow& window, const UIRect& newFrame);
 
        void notifyBackingScaleFactorChange(UIWindow& window, double newBackingScalingFactor);
    };
 
    class UIWindowFramebufferDevice : public UIWindowDevice {
        using super = UIWindowDevice;
 
    protected:
        Renderer& mRenderer;
 
        UIRenderer mUIRenderer;
 
    public:
        explicit UIWindowFramebufferDevice(Renderer& renderer);
 
    public: // Drawing
        void draw(UIBackingStore& backingStore, UIDrawCommandBuffer& drawCommandBuffer) override;
 
        [[nodiscard]] UIBackingStorePtr createBackingStore(UIWindow& window) override;
 
        void flush(UIWindow& window, UIBackingStore& backingStore) override;
    };
 
    class UIWindowSurfaceDevice : public UIWindowFramebufferDevice {
        using super = UIWindowFramebufferDevice;
 
    private:
        Platform& mPlatform;
 
        struct WindowInformation {
            UPtr<PlatformWindow> platformWindow;
 
            GPUSwapchainPtr swapchain;
 
            Array<EventConnection, 2> eventConnections;
        };
 
        HashMap<UIWindow*, WindowInformation> mWindows;
 
        Vector<UIWindowPtr> mDirtyWindows;
 
    public:
        explicit UIWindowSurfaceDevice(Platform& platform, Renderer& renderer);
 
    public: // Drawing
        [[nodiscard]] UIBackingStorePtr createBackingStore(UIWindow& window) override;
 
        void flush(UIWindow& window, UIBackingStore& backingStore) override;
 
        [[nodiscard]] double getBackingScaleFactor(const UIWindow& window) const override;
 
    public: // Window management
        [[nodiscard]] UIBackingStorePtr registerWindow(UIWindow& window) override;
 
        void unregisterWindow(UIWindow& window) override;
 
    private:
        void onSurfaceEvent(UIWindow& window, const AnyInputEvent&);
        void onSurfaceResize(UIWindow& window, const Vector2& newSize);
        void onSurfaceClose();
    };
 
} // namespace CeresEngine