Вывод графика и таблицы

#define SFML_STATIC
///----------------------------------------------------------------------------|
/// Графики.
///
///     -   Фон.
///     -   Сетка.
///     -   Координатные оси.
///     -   Графики.
///     -   <---,---> пролистывание.
///----------------------------------------------------------------------------:
///----------------------------------------------------------------------------|
/// ...
/// отключить консольное окно: -mwindows
///----------------------------------------------------------------------------:
#include <functional>
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <cmath>
 
#include <SFML/Graphics.hpp>
 
 
///----------------------------------------------------------------------------|
/// my lib: Процедуры общего назначения.
///----------------------------------------------------------------------------:
namespace myl
{
    ///--------------------------------|
    /// Линия.                         |
    ///--------------------------------:
    struct  Line
    {   sf::Vector2f a, b;
    };
 
    ///--------------------------------|
    /// unsigned ---> float            |
    ///--------------------------------:
    const sf::Vector2f W(const  sf::Vector2u& o)
    {   return                  sf::Vector2f( o.x, o.y );
    }
 
    ///--------------------------------|
    /// Центрирование примитива.       |
    ///--------------------------------:
    template<typename T>
    void setOrigin(T& o)
    {   o.setOrigin({o.getSize().x / 2, o.getSize().y / 2});
    }
 
    ///-------------------------|
    /// Интерфейс объекта.      |--------------------------------------------!!!
    ///-------------------------:
    struct      IObject : sf::Drawable
    {   virtual~IObject(){}
        virtual void update   (                        ) = 0;
        virtual bool RPControl(std::string_view command,
                               std::vector<float>& arg ) = 0;
        virtual void input(const sf::Event&       event) = 0;
 
        std::wstring_view name;
    };
}
 
 
#define INTERFACE_STUBS bool RPControl(std::string_view command,              \
                                       std::vector<float>& arg ){return true;}\
                        void input(const sf::Event&       event){            }
 
 
///----------------------------------------------------------------------------|
/// Примитивы участвующие в декорации сцены.
///----------------------------------------------------------------------------:
namespace Decorations
{
 
    ///------------------------------------------------------------------------|
    /// Фон.
    ///------------------------------------------------------------------------:
    struct  Fon : myl::IObject
    {       Fon()
            {
                name = L"Фон";
 
                figure.setFillColor   (sf::Color(0,128,0));
                figure.setSize        ({700, 450}        );
                figure.setOutlineColor(sf::Color(222,0,0));
                figure.setOutlineThickness           (5.f);
 
                myl::setOrigin(figure);
            }
 
        INTERFACE_STUBS;
 
        void update()
        {
        }
 
    private:
        sf::RectangleShape figure;
 
        virtual void draw(sf::RenderTarget& target,
                          sf::RenderStates  states) const
        {   target.draw(figure, states);
        }
    };
 
 
    ///--------------------------------|
    /// Cell: расчет сетки.            |
    ///--------------------------------:
    struct  Cell_data : public std::vector<myl::Line>
    {       Cell_data()
            {   init ();
            }
 
         static float szCell;
 
    private:
        const size_t N = 14;
 
        void init()
        {   const float LR = (szCell * N) / 2;
 
            sf::Vector2f szq{LR + 4*szCell, LR};
 
            const float& X = szq.x;
            const float& Y = szq.y;
 
            for(float a = -X, S = X + szCell; a < S; a += szCell)
            {   push_back({{a, Y}, {a, -Y}});
            }
            for(float a = -Y, S = Y + szCell; a < S; a += szCell)
            {   push_back({{X, a}, {-X, a}});
            }
        }
    };
 
    float  Cell_data::szCell = 30;
 
    ///--------------------------------|
    /// CellCoord.                     |
    ///--------------------------------:
    template<typename T>
    struct  CellCoord   : protected T, public sf::Drawable, sf::Transformable
    {       CellCoord() : NLINES (2*T::size ()),
                          lines(sf::Lines, NLINES)
            {
                const auto COLOR = sf::Color(0, 32, 0);
 
                size_t i = 0;
                for(const auto& p : *this)
                {   lines[i].position = p.a;
                    lines[i].color    = COLOR;
                        ++i;
 
                    lines[i].position = p.b;
                    lines[i].color    = COLOR;
                        ++i;
                }
            };
 
        void setColor(const sf::Color& color)
        {   for(size_t i = 0; i < NLINES; ++i)
            {   lines[i].color = color;
            }
        }
 
    private:
        const size_t   NLINES;
        sf::VertexArray lines;
 
        virtual void draw( sf::RenderTarget& target,
                           sf::RenderStates  states) const
        {   states.transform *= getTransform();
            target.draw(lines, states);
        }
    };
 
 
    ///--------------------------------|
    /// Сетка.                         |
    ///--------------------------------:
    struct  Grid : myl::IObject
    {       Grid()
            {   name = L"Сетка";
            }
 
        INTERFACE_STUBS;
 
        void update()
        {
        }
 
    private:
        CellCoord<Cell_data> cellCoord;
 
        virtual void draw( sf::RenderTarget& target,
                           sf::RenderStates  states) const
        {   target.draw(cellCoord, states);
        }
    };
 
 
    ///------------------------------------------------------------------------|
    /// Координатные оси.
    ///------------------------------------------------------------------------:
    struct  CoordLines   : myl::IObject
    {       CoordLines() : lines(sf::Lines, NLINES)
            {
                name = L"Оси";
 
                sf::Vector2f m[NLINES] =
                {   {   0, 400},
                    {   0,-400},
                    {-400,   0},
                    { 400,   0}
                };
 
                size_t i = 0;
                for(const auto& p : m)
                {   lines[i].position = p;
                    lines[i].color    = sf::Color::Yellow; ++i;
                }
            };
 
        INTERFACE_STUBS;
 
        void update()
        {
        }
 
    private:
        const size_t NLINES = 4;
        sf::VertexArray   lines;
 
        virtual void draw(sf::RenderTarget& target,
                          sf::RenderStates  states) const
        {   target.draw(lines, states);
        }
    };
 
 
    ///------------------------------------------------------------------------|
    /// Треугольник-data.
    ///------------------------------------------------------------------------:
    struct  Triangle_data   : public std::vector<myl::Line>
    {       Triangle_data() : m(*this)
            {   init();
            }
 
    private:
        std::vector<myl::Line>& m;
 
        using Plot = sf::Vector2f;
        using Line = myl::Line;
 
        void init()
        {   Plot A{  0,    0 };
            Plot B{130,  -50 };
            Plot C{100,  -100};
 
            Line AB{A, B};
            Line AC{A, C};
            Line BC{B, C};
 
            push_back(AB);
            push_back(AC);
            push_back(BC);
        }
    };
 
 
    ///------------------------------------------------------------------------|
    /// Треугольник-render.
    ///------------------------------------------------------------------------:
    struct  Triangle_render : myl::IObject, public sf::Transformable
    {       Triangle_render()
            {   name = L"Треугольник";
                triangle_render.setColor(sf::Color::White);
            }
 
        INTERFACE_STUBS;
 
        void update()
        {   setRotation(a += 0.5f);
        }
 
    private:
        CellCoord<Triangle_data> triangle_render;
        float a = 0;
 
        virtual void draw( sf::RenderTarget& target,
                           sf::RenderStates  states) const
        {
            states.transform *= getTransform();
            target.draw(triangle_render,  states);
        }
    };
}
 
namespace decor = Decorations;
 
///----------------------------------------------------------------------------|
/// Graf: График + декорации.
///----------------------------------------------------------------------------:
namespace Graf
{
    using func1_t = std::function<float(float)>;
 
    ///------------------------------------------------------------------------|
    /// User function.
    ///------------------------------------------------------------------------:
    struct  UserFunc : myl::IObject
    {       UserFunc(std::wstring_view _name, func1_t f,
                     float  w = 400.f,
                     size_t i = 200  )
                :
                     foo   (  f),
                     W     (  w),
                     NLINES(  i + 1),
                     lines ( sf::LinesStrip, NLINES)
            {
                name = _name;
                calc();
            }
 
        INTERFACE_STUBS;
 
        void update()
        {
        }
 
    private:
        func1_t foo;
        const float W;
 
        void calc()
        {
            size_t i = 0;
 
            const float d = W / (NLINES-1);
 
            for ( float x = -W / 2; i < NLINES; x += d, ++i)
            {
                lines[i].position = {x, foo(x)};
                lines[i].color    = COLOR;
            }
        }
 
        const size_t   NLINES;
        sf::VertexArray lines;
 
        const sf::Color COLOR = sf::Color(255, 255, 255);
 
        virtual void draw(  sf::RenderTarget& target,
                            sf::RenderStates  states) const
        {   target.draw(lines,  states);
        }
    };
 
 
    ///------------------------------------------------------------------------|
    /// Управление юзерскими функциями.
    ///------------------------------------------------------------------------:
    struct  ManagerUserFunc : sf::Drawable
    {       ManagerUserFunc()
            {
                d.push_back(std::make_unique<decor::Fon       >());
                d.push_back(std::make_unique<decor::Grid      >());
                d.push_back(std::make_unique<decor::CoordLines>());
 
                f.push_back(std::make_unique<UserFunc>(L"Парабола", f0));
                f.push_back(std::make_unique<UserFunc>(L"Синус"   , f1, 700));
                f.push_back(std::make_unique<decor::Triangle_render> ());
 
                font.loadFromFile    ("PT Mono.ttf");
                text.setFont                  (font);
                text.setCharacterSize           (36);
                text.setFillColor(sf::Color::Yellow);
                text.setPosition({30, -280});
                text.setString  (f[0]->name.data());
            }
 
        void keyboard(sf::Event& event)
        {
            switch (event.key.code)
            {
                case sf::Keyboard::Left:
                    if(now > 0) --now;
                    else          now = f.size() - 1;
 
                    text.setString  (f[now]->name.data());
                    break;
 
                case sf::Keyboard::Right:
                    if(now < f.size() - 1) ++now;
                    else                     now = 0;
 
                    text.setString  (f[now]->name.data());
                    break;
 
                default: break;
            }
        }
 
        void update()
        {   f[now]->update();
        }
 
    private:
        const float A = decor::Cell_data::szCell / 1.57f;
 
        unsigned now = 0;
 
        std::vector<std::unique_ptr<myl::IObject>> d;
        std::vector<std::unique_ptr<myl::IObject>> f;
 
        func1_t f0 = [    ](float x){ return     -x*x / decor::Cell_data::szCell;};
        func1_t f1 = [this](float x){ return sinf(x / A) * 60;};
 
        sf::Font font;
        sf::Text text;
 
        virtual void draw(  sf::RenderTarget& target,
                            sf::RenderStates  states) const
        {
            for(const auto& p : d){ target.draw(*p     , states); }
                                    target.draw(*f[now], states);
                                    target.draw( text  , states);
        }
    };
}
 
 
///----------------------------------------------------------------------------|
/// Run
///----------------------------------------------------------------------------:
struct  Run
{       Run() : window  (sf::VideoMode(800, 600), L"Lesson: Рисуем график")
        {
          //font.loadFromFile  ("c:/windows/fonts/georgia.ttf");  ///<-------!!!
            font.loadFromFile  ("PT Mono.ttf");
 
            text.setFont                  (font);
            text.setCharacterSize           (18);
            text.setStyle    (sf::Text::Regular);
            text.setFillColor(sf::Color::Yellow);
 
            camera.setCenter(0, 0);
            camera.setSize(myl::W(window.getSize()));
 
            camgui = window.getView(      );
                     window.setView(camera);
 
            window.setVerticalSyncEnabled(true);
 
            loop();
        }
 
private:
    ///---------------------------|
    /// Окно.                     |
    ///---------------------------:
    sf::RenderWindow        window;
 
    ///---------------------------|
    /// Гуй-элементы.             |
    ///---------------------------:
    sf::View                camgui;
    sf::Font                  font;
    sf::Text                  text;
 
    ///---------------------------|
    /// Графон-элементы.          |
    ///---------------------------:
    sf::View                 camera;
    Graf::ManagerUserFunc mUserFunc;
 
    void process_mouse(const sf::Vector2i& mouse_pos)
    {   std::string s("XY = [");
                    s += std::to_string(mouse_pos.x) + ", ";
                    s += std::to_string(mouse_pos.y) + "]" ;
        text.setString(s);
    }
 
    ///------------------------------------------------|
    /// Базовый цикл.                                  |
    ///------------------------------------------------:
    void loop()
    {
        sf::Vector2i mouse_pos;
 
        while (window.isOpen())
        {
            ///----------------------------------------|
            /// Юзер-управление.                       |
            ///----------------------------------------:
            for (sf::Event event; window.pollEvent(event);)
            {
                if (event.type == sf::Event::Closed) window.close();
 
                ///------------------------------------|
                /// MouseMoved только здесь.           |
                ///------------------------------------:
                if (event.type == sf::Event::MouseMoved)
                {   mouse_pos  =  sf::Mouse::getPosition(window);
                    process_mouse(mouse_pos);
                }
 
                ///------------------------------------|
                /// Тётя Клава.                        |
                ///------------------------------------:
                if (event.type == sf::Event::KeyPressed)
                {   mUserFunc.keyboard(event);
 
                    if (event.key.code == sf::Keyboard::Escape) window.close();
                }
            }
 
            mUserFunc.update();
 
            ///----------------------------------------|
            /// Рендер.                                |
            ///----------------------------------------:
            window.clear        ();
 
            ///-------------------|
            /// Рисуем график.    |
            ///-------------------:
            window.setView(camera);
            window.draw(mUserFunc);
 
            ///-------------------|
            /// Рисуем гуй.       |
            ///-------------------:
            window.setView(camgui);
            window.draw     (text);
 
            window.display      ();
        }
    }
};
 
///----------------------------------------------------------------------------|
/// Start.
///----------------------------------------------------------------------------:
int main()
{   std::unique_ptr<Run> run(new Run);
}