Создайте абстрактный класс для работы с геометрическими фигурами на экране

#include <iostream>
#include <iomanip>
#include <cmath>
 
struct Angle {
public:
    static constexpr float pi = 3.141592654f;
 
    constexpr Angle(float radians) : radians(radians) {}
 
    constexpr float asRadians() const {
        return radians;
    }
 
    constexpr float asDegrees() const {
        return radians * 180 / pi;
    }
 
    static constexpr Angle inDegrees(float degrees) {
        return degrees * pi / 180;
    }
 
private:
    float radians;
};
 
constexpr Angle operator+(const Angle &a, const Angle &b) {
    return {a.asRadians() + b.asRadians()};
}
 
constexpr Angle operator-(const Angle &a, const Angle &b) {
    return {a.asRadians() - b.asRadians()};
}
 
constexpr Angle operator*(const Angle &a, float value) {
    return {a.asRadians() * value};
}
constexpr Angle operator*(float value, const Angle &a) {
    return {a.asRadians() * value};
}
 
struct Vector2 {
    float x;
    float y;
 
    constexpr Vector2() : x(), y() {}
 
    constexpr Vector2(float x, float y) : x(x), y(y) {}
 
    Vector2(float magnitude, Angle angle) :
            x(magnitude * std::cos(angle.asRadians())),
            y(magnitude * std::sin(angle.asRadians())) {}
 
    constexpr float length() const {
        return std::sqrt(lengthSq());
    }
 
    constexpr float lengthSq() const {
        return dot(*this);
    }
 
    constexpr float dot(const Vector2 &other) const {
        return x * other.x + y * other.y;
    }
 
};
 
Vector2 operator+(const Vector2 &a, const Vector2 &b) {
    return {a.x + b.x, a.y + b.y};
}
 
class Transform {
public:
    constexpr Transform() : matrix{
            1, 0, 0, 0,
            0, 1, 0, 0,
            0, 0, 1, 0,
            0, 0, 0, 1,
    } {}
 
    constexpr Transform(float a00, float a01, float a02,
                        float a10, float a11, float a12,
                        float a20, float a21, float a22) :
            matrix{
                    a00, a10, 0, a20,
                    a01, a11, 0, a21,
                    0, 0, 1, 0,
                    a02, a12, 0, a22
            } {}
 
    constexpr Vector2 transformPoint(const Vector2 &point) const {
        return Vector2(matrix[0] * point.x + matrix[4] * point.y + matrix[12],
                       matrix[1] * point.x + matrix[5] * point.y + matrix[13]);
 
    }
 
private:
    // opengl совместимая 3d матрица трансормаций
    float matrix[16];
};
 
class Transformable {
public:
    Transformable() : origin(0, 0), position(0, 0), rotation(0), scaling(0, 0) {}
 
    Transformable(const Vector2 &origin, const Vector2 &position, const Angle &rotation,
                  const Vector2 &scaling) : origin(origin), position(position), rotation(rotation),
                                            scaling(scaling) {}
 
    virtual ~Transformable() = default;
 
    const Vector2 &getOrigin() const {
        return origin;
    }
 
    void setOrigin(const Vector2 &origin) {
        Transformable::origin = origin;
    }
 
    const Vector2 &getPosition() const {
        return position;
    }
 
    void setPosition(const Vector2 &position) {
        Transformable::position = position;
    }
 
    const Angle &getRotation() const {
        return rotation;
    }
 
    void setRotation(const Angle &rotation) {
        Transformable::rotation = rotation;
    }
 
    const Vector2 &getScale() const {
        return scaling;
    }
 
    void setScale(const Vector2 &scale) {
        Transformable::scaling = scale;
    }
 
    // relative change not setting
    void move(const Vector2 &offset) {
        setPosition(position + offset);
    }
 
    // relative change not setting
    void scale(const Vector2 &factor) {
        setScale({scaling.x * factor.x, scaling.y * factor.y});
    }
 
    // relative change not setting
    void rotate(const Angle angle) {
        setRotation(rotation + angle);
    }
 
    constexpr Transform getTransform() const {
        float angle = -rotation.asRadians();
        float cosine = std::cos(angle);
        float sine = std::sin(angle);
        float scaleXCosine = scaling.x * cosine;
        float scaleYCosine = scaling.y * cosine;
        float scaleXSine = scaling.x * sine;
        float scaleYSine = scaling.y * sine;
        float tx = -origin.x * scaleXCosine - origin.y * scaleYSine + position.x;
        float ty = origin.x * scaleXSine - origin.y * scaleYCosine + position.y;
 
        return {scaleXCosine, scaleYSine, tx,
                -scaleXSine, scaleYCosine, ty,
                0, 0, 1};
    }
 
private:
    Vector2 origin;    // origin of translation/rotation/scaling of the object
    Vector2 position;  // position of the object in the 2D world
    Angle rotation;       // orientation of the object
    Vector2 scaling;   // scaling of the object
};
 
class Shape : public Transformable {
public:
    Shape() : Transformable(), visible(true) {}
 
    Shape(const Vector2 &origin, const Vector2 &position, const Angle &rotation,
          const Vector2 &scaling) : Transformable(origin, position, rotation, scaling), visible(true) {}
 
    virtual std::size_t getPointCount() const = 0;
 
    virtual Vector2 getPoint(std::size_t index) const = 0;
 
    virtual bool isVisible() const {
        return visible;
    };
 
    virtual void setVisible(bool visible) {
        Shape::visible = visible;
    }
 
private:
    bool visible;
};
 
class CircleShape : public Shape {
public:
    CircleShape() : Shape(), radius(0), pointCount(0) {}
 
    CircleShape(float radius, size_t pointCount) :
            Shape({radius, radius}, {0, 0}, {0}, {1, 1}),
            radius(radius), pointCount(pointCount) {}
 
    size_t getPointCount() const override {
        return pointCount;
    }
 
    Vector2 getPoint(std::size_t index) const override {
        Angle angle = static_cast<float>(index) / static_cast<float>(pointCount) * Angle(Angle::pi * 2) - Angle(Angle::pi / 2.);
        return Vector2(radius, radius) + Vector2(radius, angle);
    }
 
private:
    float radius;
    std::size_t pointCount;
};
 
std::ostream &operator<<(std::ostream &out, const Vector2 &v) {
    return out << "(" << v.x << "," << v.y << ")";
}
 
struct Canvas {
    void draw(const Shape &shape) {
        if (shape.isVisible()) {
            Transform transform = shape.getTransform();
 
            for (std::size_t i = 0; i != shape.getPointCount(); ++i) {
                std::cout << std::fixed << std::setprecision(5) << transform.transformPoint(shape.getPoint(i));
                if (i + 1 < shape.getPointCount()) {
                    std::cout << ", ";
                }
            }
            std::cout << std::endl;
        }
    }
};
 
class RectangleShape : public Shape {
public:
    RectangleShape(const Vector2 &diagonal) :
            Shape({0, 0}, {0, 0}, {0}, {1, 1}),
            diagonal(diagonal) {}
 
    size_t getPointCount() const override {
        return 4;
    }
 
    Vector2 getPoint(std::size_t index) const override {
        switch (index)
        {
            default:
            case 0: return Vector2(0, 0);
            case 1: return Vector2(diagonal.x, 0);
            case 2: return Vector2(diagonal.x, diagonal.y);
            case 3: return Vector2(0, diagonal.y);
        }
    }
 
private:
    Vector2 diagonal;
};
 
int main() {
    Canvas canvas;
 
    CircleShape circle(10, 360);
    circle.setVisible(true);
    circle.rotate(3);
    circle.move({1, 1});
    canvas.draw(circle);
}