SfmlTypes.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2023
** R-Type
** File description:
** SfmlTypes
*/
 
#ifndef SFMLTYPES_HPP_
#define SFMLTYPES_HPP_
#include <SFML/Audio.hpp>
#include <SFML/Graphics.hpp>
#include "utils/Vector.hpp"
#include "utils/Rect.hpp"
#include "unordered_map"
#include "RenderInterfaces.hpp"
#include "Keyboard.hpp"
 
#ifdef DEBUG
    #include "Debug.hpp"
    #include <imgui.h>
    #include <imgui-SFML.h>
    #include "Error.hpp"
#endif
 
namespace GameEngine
{
    class SEvent : public IEvent<sf::Event>
    {
      public:
        SEvent() = default;
        sf::Event &getEvent() override { return _event; }
        sf::Event::EventType &type = _event.type;
 
      private:
        sf::Event _event;
    };
 
    class Clock : public IClock<sf::Clock>
    {
      public:
        Clock() = default;
        sf::Clock &getClock() override { return _clock; }
 
      private:
        sf::Clock _clock;
    };
 
    class Texture : public ITexture<sf::Texture, sf::Rect>
    {
      public:
        Texture() = default;
        ~Texture() = default;
        const sf::Texture &getTexture() const override { return _texture; };
        void load(const std::string &filename, const IRect<int, sf::Rect> &area) override
        {
            _texture.loadFromFile(filename, area.getBaseRect());
        }
 
      private:
        sf::Texture _texture;
    };
 
    class View : public IView<sf::View>
    {
      public:
        View() = default;
        View(const Rect<float> &rect) : _view{sf::Rect<float>{rect.left, rect.top, rect.width, rect.height}} {};
        ~View() = default;
        const sf::View &getBaseView() const override { return _view; }
        void setCenter(const Vector2<float> &center) override { _view.setCenter(center.x, center.y); }
        Vector2<float> getCenter() const override
        {
            auto center = _view.getCenter();
            return Vector2<float>{center.x, center.y};
        }
        void setViewPort(const Vector2<float> &startingPoint, float width, float height) override
        {
            _view.setViewport(sf::FloatRect{startingPoint.x, startingPoint.y, width, height});
        }
 
      private:
        sf::View _view;
    };
 
    class Window : public IWindow<sf::RenderWindow, sf::View, sf::Event, sf::Drawable>
    {
      public:
#ifdef DEBUG
#endif
#ifdef DEBUG
        Window(
            Debug::DebugMenu &debugMenu, int width = 1920, int height = 1080, const std::string &title = "Game window")
            : _window(sf::VideoMode(width, height), title), _title(title), _debugMenu(debugMenu)
        {
        }
#else
        Window(int width = 1920, int height = 1080, const std::string &title = "Game window")
            : _window(sf::VideoMode(width, height), title), _title(title)
        {
        }
#endif
        const sf::RenderWindow &getWindow() const override { return _window; }
        sf::RenderWindow &getWindow() override { return _window; }
        void draw(const sf::Drawable &drawable) override { _window.draw(drawable); }
        void setView(const IView<sf::View> &view) override { _window.setView(view.getBaseView()); };
        void setFramerateLimit(const float rate) override { _window.setFramerateLimit(rate); };
        bool isOpen() const override { return _window.isOpen(); }
        bool pollEvent(IEvent<sf::Event> &event) override
        {
            bool result = _window.pollEvent(event.getEvent());
#ifdef DEBUG
            ImGui::SFML::ProcessEvent(_window, event.getEvent());
#endif
            return result;
        }
        void close() override { _window.close(); }
        void display() override { _window.display(); };
        void clear() override { _window.clear(); };
        void create(int width, int height, const std::string &title) override
        {
            _window.create(sf::VideoMode(width, height), title);
            _title = title;
        }
        Vector2<float> mapPixelToCoords(const Vector2<int> &pos)
        {
            sf::Vector2f coord = _window.mapPixelToCoords(sf::Vector2i(pos.x, pos.y));
            return Vector2<float>(coord.x, coord.y);
        };
 
#ifdef DEBUG
        void initDebug() override
        {
            if (!ImGui::SFML::Init(_window))
                throw Error::ImGuiSFMLInitError();
            ImGuiIO &io = ImGui::GetIO();
            io.IniFilename = NULL;
            io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
        }
        void shutdownDebug() override { ImGui::SFML::Shutdown(); }
        void drawDebug() override
        {
            ImGui::SFML::Update(_window, _debugClock.getClock().restart());
            _debugMenu.draw();
            ImGui::SFML::Render(_window);
        }
#endif
 
      private:
        sf::RenderWindow _window;
        std::string _title;
#ifdef DEBUG
        Debug::DebugMenu &_debugMenu;
        Clock _debugClock;
#endif
    };
 
    class Text
    {
      public:
        Text(){};
        ~Text() = default;
        const sf::Text &getText() const { return _text; }
        void load(const std::string &text, const sf::Font &font, size_t size)
        {
            _text.setString(text);
            _text.setFont(font);
            _text.setCharacterSize(size);
        }
        void setPosition(const Vector2<float> &position)
        {
            _text.setPosition(static_cast<int>(position.x), static_cast<int>(position.y));
        }
        void setString(const std::string &string) { _text.setString(string); }
 
        Rectf getLocalBounds() const
        {
            return Rectf(_text.getLocalBounds().left, _text.getLocalBounds().top, _text.getLocalBounds().width,
                _text.getLocalBounds().height);
        }
 
      private:
        sf::Text _text;
    };
    class Music : public IMusic<sf::Music>
    {
      public:
        Music(){};
        ~Music() = default;
        const sf::Music &getMusic() const override { return _music; }
        void load(const std::string &filename)
        {
            _music.openFromFile(filename);
            _filename = filename;
        }
        void play() override
        {
            if (_music.getStatus() == sf::Music::Status::Stopped) {
                _music.play();
            }
        }
        const std::string &getFilename() const { return _filename; }
 
      private:
        sf::Music _music;
        std::string _filename;
    };
 
    class Font : public IFont<sf::Font>
    {
      public:
        Font(){};
        ~Font() = default;
        const sf::Font &getFont() const override { return _font; };
        void load(const std::string &filename) override { _font.loadFromFile(filename); }
 
      private:
        sf::Font _font;
    };
    class Sprite : public ISprite<sf::Sprite, sf::Texture, sf::Rect>
    {
      public:
        Sprite(){};
        ~Sprite() = default;
        const sf::Sprite &getSprite() const override { return _sprite; };
        void load(const ITexture<sf::Texture, sf::Rect> &texture, bool resetRect = false) override
        {
            _sprite.setTexture(texture.getTexture(), resetRect);
        };
        void setPosition(const Vector2<float> position) override
        {
            _sprite.setPosition(sf::Vector2f{position.x, position.y});
        };
        void setTextureRect(const IRect<int, sf::Rect> &newRect) override
        {
            _sprite.setTextureRect(newRect.getBaseRect());
        };
        void setRect(const Recti &rect) { _sprite.setTextureRect(rect.getBaseRect()); };
        void setScale(const float &x, const float &y) { _sprite.setScale(x, y); };
 
      private:
        sf::Sprite _sprite;
    };
 
    class InputManager
    {
      public:
        static const std::unordered_map<Input::Keyboard::Key, sf::Keyboard::Key> sfKeys;
 
        static bool isKeyPressed(const Input::Keyboard::Key key) { return sf::Keyboard::isKeyPressed(sfKeys.at(key)); }
 
        static bool isKeyReleased(const Input::Keyboard::Key key)
        {
            bool isReleased = prevKeyStates[key] && sf::Keyboard::isKeyPressed(sfKeys.at(key)) == false;
            prevKeyStates[key] = sf::Keyboard::isKeyPressed(sfKeys.at(key));
 
            return isReleased;
        }
 
      private:
        static std::unordered_map<Input::Keyboard::Key, bool> prevKeyStates;
    };
} // namespace GameEngine
#endif /* !MLTYPES_HPP_ */