Camera.hpp

#pragma once

#include <memory>
#include <optional>

#include <SFML/Graphics/RenderTexture.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/Transformable.hpp>
#include <SFML/Graphics/View.hpp>

#include <NasNas/core/data/Rect.hpp>
#include <NasNas/core/data/ShaderHolder.hpp>

namespace ns {
    class Scene;

    class Camera : public sf::View, public ShaderHolder {
        friend class App;
    public:
        Camera(std::string name, int render_order);

        Camera(const Camera&) = delete;
        Camera(Camera&&) = default;
        Camera& operator=(const Camera&) = delete;
        Camera& operator=(Camera&&) = default;

        void reset(int x, int y, int w, int h);

        void reset(const sf::Vector2i& position, const sf::Vector2i& size);

        void reset(const ns::IntRect& rect) ;

        void resetViewport(float x, float y, float w, float h);

        void resetViewport(const sf::Vector2f& position, const sf::Vector2f& size);

        void resetViewport(const sf::FloatRect& rect);

        auto getViewport() const -> const ns::FloatRect& ;

        auto hasScene() -> bool;

        void lookAt(Scene& scene);

        auto isVisible() const -> bool;
        void setVisible(bool value);

        void follow(sf::Transformable& transformable);

        void unfollow();

        auto getRenderOrder() const -> int;

        auto getFramesDelay() const -> unsigned int;

        void setFramesDelay(unsigned int value);

        void setLimitsRect(const ns::IntRect& rectangle);

        auto getPosition() const -> sf::Vector2f;

        auto getFolloweePosition() const -> const sf::Vector2f&;

        auto getLeft() const -> float;

        void setLeft(float value);

        auto getRight() const -> float;

        void setRight(float value);

        auto getTop() const -> float;

        void setTop(float value);

        auto getBottom() const -> float;

        void setBottom(float value);

        auto getGlobalBounds() const -> ns::FloatRect;

        void update();

    private:
        std::string m_name;                 
        int m_render_order;                 
        bool m_visible;                     
        Scene* m_scene;                     

        std::optional<sf::Transformable*> m_followee; 
        unsigned int m_frames_delay;        

        ns::IntRect m_base_view;            
        ns::FloatRect m_base_viewport;      
        ns::IntRect m_limits = {0, 0, 0, 0};

        std::unique_ptr<sf::RenderTexture> m_render_texture;
        sf::Sprite m_sprite;                

        void render(sf::RenderTarget& target);

        auto getSprite() const -> const sf::Sprite&;

        using sf::View::reset;
        using sf::View::setViewport;

    };

}