wGraphicsEntity.hpp

Go to the documentation of this file.

/*
+---------------------------------------------------------------------------------------------------------------------------------------------------+
Created by Wilfried Koch.
Copyright @ 2025 Wilfried Koch. All rights reserved.
+---------------------------------------------------------------------------------------------------------------------------------------------------+
*/
 
#ifndef W_GRAPHICS_ENTITY_HPP
#define W_GRAPHICS_ENTITY_HPP
 
#include "../srcEntity/wEntity.hpp"
 
#include "../srcUtils/wAssetManager.hpp"
#include "../srcUtils/wPathUtils.hpp"
 
#include "wAxisEntity.hpp"
#include "wTitleEntity.hpp"
#include "wFunctionEntity.hpp"
#include "wDataPlotEntity.hpp"
#include "wLegendEntity.hpp"
#include "wLineEntity.hpp"
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#pragma GCC diagnostic ignored "-Wswitch-default"
#include <SFML/Graphics.hpp>
#pragma GCC diagnostic pop
 
namespace wPlot2D
{

    enum class TitleAlignment
    {
        Top,
        Bottom
    };

    class GraphicsEntity : public wEngine::Entity
    {
        public:
            GraphicsEntity(
                const std::string& windowTitle  = "wPlot2D",
                const sf::Vector2u& windowSize = { 1600, 1600 },
                const sf::Vector2f& originFactor = { 0.5f, 0.5f },
                const sf::Vector2f& scaleFactor  = { 0.1f, 0.1f } );

            virtual ~GraphicsEntity( ) = default;

            [[nodiscard]] sf::RenderWindow& getWindow( );

            [[nodiscard]] sf::Vector2u getWindowSize( ) const;

            void setWindowSize( const sf::Vector2u& newSize );

            void setWindowTitle( const std::string& title );

            void setBackgroundColor( const sf::Color& color );

            void addFont( const std::string& name, const std::string& fileName );

            sf::Font& getFont( const std::string name );

            [[nodiscard]] sf::Vector2f getOrigin( ) const;

            void setOrigin( sf::Vector2f originFactor );

            [[nodiscard]] sf::Vector2f getScale( ) const;

            void setScale( sf::Vector2f scaleFactor );

            [[nodiscard]] sf::Vector2f getOffset( ) const;

            void setOffset( sf::Vector2f offset );

            [[nodiscard]] AxisEntity* addAxis( AxisType type, sf::Vector2f axisRange );

            [[nodiscard]] TitleEntity* addTitle( const std::string& title, TitleAlignment alignment = TitleAlignment::Bottom );

            [[nodiscard]] TitleEntity* addTitle( const std::wstring& title, TitleAlignment alignment = TitleAlignment::Bottom );

            [[nodiscard]] FunctionEntity* addFunction( std::function< double( double )> func, 
                double startX, double endX, size_t nbPoints = 1000 );

            [[nodiscard]] DataPlotEntity* addDataPlot( const std::vector< sf::Vector2f >& dataPoints );

            [[nodiscard]] LegendEntity* addLegend( const sf::Vector2f& position, bool hasFrame = true );

            [[nodiscard]] TitleEntity* addText( const std::string& text, sf::Vector2f position );

            [[nodiscard]] TitleEntity* addText( const std::wstring& text, sf::Vector2f position );

            [[nodiscard]] LineEntity* addLine( const sf::Vector2f& start, const sf::Vector2f& end, bool withArrow = false );

            void saveToFile( const std::string& filename );
        private:
            sf::RenderWindow mWindow;
            wEngine::AssetManager mAssets;
            std::unique_ptr< AxisEntity > mAxisX;
            std::unique_ptr< AxisEntity > mAxisY;
            std::unique_ptr< TitleEntity > mTitle;
            TitleAlignment mAlignment;
 
            template < typename T >
            TitleEntity* addTitleImpl( const T& title, TitleAlignment alignment );
 
            template < typename T >
            TitleEntity* initText( const T& title, sf::Vector2f position );
 
            struct FunctionData
            {
                std::unique_ptr< FunctionEntity > entity;
                double startX;
                double endX;
                size_t nbPoints;
            };
            std::vector< FunctionData > mFunctions;
 
            struct DataPlotData
            {
                std::unique_ptr< DataPlotEntity > entity;
            };
            std::vector< DataPlotData > mDataPlots;
 
            std::unique_ptr< LegendEntity > mLegend;
 
            struct TextData
            {
                std::unique_ptr< TitleEntity > entity;
            };
            std::vector< TextData > mTexts;
 
            struct LineData
            {
                std::unique_ptr< LineEntity > entity;
            };
            std::vector< LineData > mLines;

            void render( );

            void validateNormalizedFactor( const sf::Vector2f& factor ) const;

            [[nodiscard]] sf::Vector2f convertNormalizedToPixels( const sf::Vector2f& factor ) const;
    };
 
}//End of namespace wPlot2D
 
#endif