UIViewport.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/UI/UIView.hpp"
#include "CeresEngine/UI/UIViewController.hpp"
#include "CeresEngine/Scene/Camera.hpp"
#include "CeresEngine/Scene/Light.hpp"
#include "CeresEngine/Scene/Scene.hpp"
 
namespace CeresEngine {
 
    class UIViewportDelegate;
    class UIGizmo;
 
    class UIViewport : public UIView {
    private:
        HScene mScene;
 
        GPUDevice& mDevice;
 
        SceneObject mParentSO;
 
        Camera mCamera;
 
        GPUImagePtr mImage;
 
        GPUTexturePtr mTexture;
 
        bool mContinuousRedraw = false;
 
        UIGizmo* mGizmo = nullptr;
        SceneObject mTrackingObject;
 
    public:
        struct {
            UIDelegate<UIViewport, bool(const GPUImagePtr& oldImage, const UISize& newSize)> shouldRecreateRenderTarget;
 
            UIDelegate<UIViewport, void(const GPUImagePtr& oldImage, const UISize& newSize)> willRecreateRenderTarget;
 
            UIDelegate<UIViewport, void()> didRecreateRenderTarget;
        } delegate;
 
    public:
        explicit UIViewport(GPUDevice& device, const HScene& scene) : UIViewport(kDefaultFrame, device, scene) {}
        explicit UIViewport(const UIRect& frame, GPUDevice& device, const HScene& scene);
        ~UIViewport() override;
 
    public:
        const Camera& getCamera() const noexcept { return mCamera; }
 
        const HScene& getScene() const noexcept { return mScene; }
 
        void setScene(const HScene& scene);
 
        double getZoom() const;
 
        void setZoom(double zoom);
 
        const Vector3& getPosition() const;
 
        void setPosition(const Vector3& position) const;
 
        const Quaternion& getOrientation() const;
 
        void setOrientation(const Quaternion& quaternion) const;
 
        void lookAt(const SceneObject& sceneObject);
 
        void lookAt(const Vector3& point);
 
        [[nodiscard]] bool getContinuousRedraw() const noexcept { return mContinuousRedraw; }
 
        void setContinuousRedraw(bool continuousRedraw);
 
    public: // Transforms
        [[nodiscard]] AffineTransform getTransformToRenderTarget() const;
 
        [[nodiscard]] AffineTransform getTransformFromRenderTarget() const;
 
        [[nodiscard]] AffineTransform getBackingToRenderTargetTransform() const;
        [[nodiscard]] AffineTransform getRenderTargetToBackingTransform() const;
 
        [[nodiscard]] AffineTransform getWindowToRenderTargetTransform() const;
        [[nodiscard]] AffineTransform getRenderTargetToWindowTransform() const;
 
        [[nodiscard]] Vector3 convertToWorld(const UIPoint& point) const;
        [[nodiscard]] UIPoint convertFromWorld(const Vector3& position) const;
 
        [[nodiscard]] Vector3 unproject(const UIPoint& point, double z) const;
 
    public: // UIView
        void didChangeBounds(const UIRect& bounds) override;
 
        void draw(UIGraphicsContext& context, const UIRect& dirtyRect) override;
 
        [[nodiscard]] bool getClearsContextBeforeDrawing() const noexcept override { return false; }
 
    protected:
        void didMoveToSuperView(UIView* superView) override;
 
        void didMoveToWindow(UIWindow* window) override;
 
    public: // UIResponder
        bool acceptsFirstResponder() const override { return true; }
 
        void mouseDragged(const UIMouseEvent& event) override;
 
        void rightMouseDragged(const UIMouseEvent& event) override;
 
        void otherMouseDragged(const UIMouseEvent& event) override;
 
        void mouseDown(const UIMouseEvent& event) override;
 
        void mouseUp(const UIMouseEvent& event) override;
 
        void mouseMoved(const UIMouseEvent& event) override;
 
        void scrollWheel(const UIMouseEvent& event) override;
 
        void keyDown(const UIKeyEvent& event) override;
 
    private:
        void recreateRenderTarget();
    };
 
    class UIViewportDelegate {
    public:
        virtual bool shouldRecreateRenderTarget(UIViewport& view, const GPUImagePtr& oldImage, const UISize& newSize) { return true; }
 
        virtual void willRecreateRenderTarget(UIViewport& view, const GPUImagePtr& oldImage, const UISize& newSize) {}
 
        virtual void didRecreateRenderTarget(UIViewport& view) {}
    };
 
    class UIViewportViewController : public TUIViewController<UIViewport>, public UIViewportDelegate {
        using super = TUIViewController<UIViewport>;
 
    public:
        using TUIViewController::TUIViewController;
 
    public:
        void loadView(UIViewport& viewport) override;
    };
 
    template<typename ModelType> using TUIViewportViewController = UIModelViewController<ModelType, UIViewportViewController>;
 
} // namespace CeresEngine