shapedefinitions.h

#ifndef SHAPEDEFINITIONS_H
#define SHAPEDEFINITIONS_H

#include <QList>
#include <QtMath>
#include <QtDebug>

#include "../rendering/renderer.h"

namespace shapes {

class ShapeDefinitions
{
public:
    static QList<void(*)(rendering::Renderer&, int, int)> OuterShapes();
    static QList<void(*)(rendering::Renderer&, int, int)> CenterShapes();

    static void outerOne(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "outerOne";
        renderer.addTriangle(0 ,0 , cell, cell, rendering::TriangleDirection::SouthWest);
    }
    static void outerTwo(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "outerTwo";
        renderer.addTriangle(0, cell / 2.0, cell, cell / 2.0, rendering::TriangleDirection::SouthWest);
    }
    static void outerThree(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "outerThree";
        renderer.addRhombus(0, 0, cell, cell);
    }
    static void outerFour(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "outerFour";
        auto m = cell * 0.16667;
        renderer.addCircle(m, m, cell - 2 * m);
    }
    static void centerOne(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerOne";
        qreal k = cell * 0.42;
        QList<QPointF> polygon =
                {
                    QPointF(0,0),
                    QPointF(cell,0),
                    QPointF(cell,cell - k*2),
                    QPointF(cell - k, cell),
                    QPointF(0, cell)
                };
        renderer.addPolygon(polygon);
    }
    static void centerTwo(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerTwo";
        auto w = qFloor(cell * 0.5);
        auto h = qFloor(cell * 0.8);
        renderer.addTriangle(cell - w, 0, w, h, rendering::TriangleDirection::NorthEast);
    }
    static void centerThree(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerThree";
        auto s = cell / 3;
        renderer.addRectangle(s, s, cell - s, cell - s);
    }
    static void centerFour(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerFour";
        qreal tmp = cell * 0.1;

        auto inner =
            tmp > 1 ? qFloor(tmp) : // large icon => truncate decimals
            tmp > 0.5 ? 1 :      // medium size icon => fixed width
            tmp;                 // small icon => anti-aliased border

        // Use fixed outer border widths in small icons to ensure the border is drawn
        auto outer =
            cell < 6 ? 1 :
            cell < 8 ? 2 :
            cell / 4;

        renderer.addRectangle(outer, outer, cell - inner - outer, cell - inner - outer);
    }
    static void centerFive(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerFive";
        auto m = qFloor(cell * 0.15);
        auto s = qFloor(cell * 0.5);
        renderer.addCircle(cell - s - m, cell - s - m, s);
    }
    static void centerSix(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerSix";

        qreal inner = cell * 0.1;
        qreal outer = inner * 4;

        // Align edge to nearest pixel in large icons
        if (outer > 3)
        {
            outer = qFloor(outer);
        }

        renderer.addRectangle(0, 0, cell, cell);
        QList<QPointF> polygon =
        {
            QPointF(outer, outer),
            QPointF(cell - inner, outer),
            QPointF(outer + (cell - outer - inner) / 2, cell - inner)
        };
        renderer.addPolygon(polygon, true);
    }
    static void centerSeven(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerSeven";

        QList<QPointF> polygon =
        {
            QPointF(0, 0),
            QPointF(cell, 0),
            QPointF(cell, cell * 0.7),
            QPointF(cell * 0.4, cell * 0.4),
            QPointF(cell * 0.7, cell),
            QPointF(0, cell)
        };
        renderer.addPolygon(polygon);
    }
    static void centerEight(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerEight";

        renderer.addTriangle(cell / 2.0, cell / 2.0, cell / 2.0, cell / 2.0, rendering::TriangleDirection::SouthEast);
    }
    static void centerNine(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerNine";

        QList<QPointF> polygons =
        {
            QPointF(0, 0),
            QPointF(cell, 0),
            QPointF(cell, cell / 2),
            QPointF(cell / 2, cell),
            QPointF(0, cell)
        };
        renderer.addPolygon(polygons);
    }
    static void centerTen(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "centerTen";

        qreal tmp = cell * 0.14;
        auto inner =
             cell < 8 ? tmp : // small icon => anti-aliased border
             qFloor(tmp);        // large icon => truncate decimals

         // Use fixed outer border widths in small icons to ensure the border is drawn
         auto outer =
             cell < 4 ? 1 :
             cell < 6 ? 2 :
             qFloor(cell * 0.35);

        renderer.addRectangle(0, 0, cell, cell);
        renderer.addRectangle(outer, outer, cell - outer - inner, cell - outer - inner, true);
    }
    static void centerEleven(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "center11";

        qreal inner = cell * 0.12;
        qreal outer = inner * 3;

        renderer.addRectangle(0, 0, cell, cell);
        renderer.addCircle(outer, outer, cell - inner - outer, true);
    }
    static void centerTwelve(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);
        qDebug() << "center12";


        renderer.addTriangle(cell / 2.0, cell / 2.0, cell / 2.0, cell / 2.0, rendering::TriangleDirection::SouthEast);
    }
    static void centerThirteen(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);

        qDebug() << "center13";


        qreal m = cell * 0.25;

        renderer.addRectangle(0, 0, cell, cell);
        renderer.addRhombus(m, m, cell - m, cell - m, true);
    }
    static void centerFourteen(rendering::Renderer &renderer, int cell, int index)
    {
        Q_UNUSED(index);

        qDebug() << "center14";


        qreal m = cell * 0.4;
        qreal s = cell * 1.2;

        if (index != 0)
        {
            renderer.addCircle(m, m, s);
        }
    }

    static void (*outerShapes_[4])(rendering::Renderer &, int , int );
    static void (*centerShapes_[14])(rendering::Renderer &, int , int );
};

} // namespace shapes

#endif // SHAPEDEFINITIONS_H