PointProperty.h

Go to the documentation of this file.

#pragma once
 
#include "Point.h"
#include "../Property.h"
 
namespace Gorgon { namespace Geometry {
    
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    class basic_PointProperty : Property<C_, T_, Getter_, Setter_> {
    public:
        
        basic_PointProperty(C_ *object) : 
        Property<C_,T_, Getter_, Setter_>(object), 
        X(this), Y(this)
        { }
 
        basic_PointProperty(C_ &object) : basic_PointProperty(&object)
        { }
        
        basic_PointProperty(basic_PointProperty &&) = default;
        
        basic_PointProperty& operator=(basic_PointProperty &&) = default;
 
        operator T_() { 
            return (this->Object.*Getter_)(); 
        }
 
        operator const T_() const { 
            return (this->Object.*Getter_)(); 
        }
 
        basic_PointProperty &operator =(const T_ &value) { 
            (this->Object.*Setter_)(value);
 
            return *this;
        }
 
        T_ operator - (const T_ &point) const {
            return this->Get() - point;
        }
 
        T_ operator -() const {
            return -this->Get();
        }
 
        T_ operator + (const T_ &point) const {
            return this->Get() + point;
        }
 
        template <class O_>
        T_ operator * (O_ value) const {
            return this->Get() * value;
        }
 
        T_ operator *(const T_ &value) const {
            return this->Get() * value;
        }
 
        template <class O_>
        T_ operator / (O_ value) const {
            return this->Get() / value;
        }
 
        basic_PointProperty &operator -= (const T_ &point) {
            this->Set(this->Get() - point);
 
            return *this;
        }
 
        basic_PointProperty &operator += (const T_ &point) {
            this->Set(this->Get() + point);
 
            return *this;
        }
 
        template <class O_>
        basic_PointProperty &operator *= (O_ value) {
            this->Set(this->Get() * value);
 
            return *this;
        }
 
        template <class O_>
        basic_PointProperty &operator /= (O_ value) {
            this->Set(this->Get() / value);
 
            return *this;
        }
 
        T_ CrossProduct(const T_ &value) const {
            return this->Get().CrossProduct(value);
        }
 
        T_ DotProduct(const T_ &value) const {
            return this->Get().DotProduct(value);
        }
 
 
        Float Distance(const T_ &target) const {
            return this->Get().Distance(target);
        }
        Float EuclideanSquare(const T_ &target) const {
            return this->Get().EuclideanSquare(target);
        }
        Float Distance() const {
            return this->Get().Distance();
        }
 
        Float EuclideanSquare() const {
            return this->Get().EuclideanSquare();
        }
        Float ManhattanDistance(const T_ &target) const {
            return this->Get().ManhattanDistance(target);
        }
 
        Float ManhattanDistance() const {
            return this->Get().ManhattanDistance();
        }
        
        T_ Normalize() const {
            return this->Get().Normalize();
        }
        
        T_ Perpendicular() const {
            return this->Get().Perpendicular();
        }
 
        Float Angle(const T_ &origin) const {
            return this->Get().Angle(origin);
        }
 
        Float Angle() const {
            return this->Get().Angle();
        }
 
        Float Slope(const T_ &point) const {
            return this->Get().Slope(point);
        }
 
        Float Slope() const {
            return this->Get().Slope();
        }
 
        bool Compare(const T_ &point) const {
            return this->Get().Compare(point);
        }
 
        bool operator == (const T_ &point) const {
            return Compare(point);
        }
 
        bool operator !=(const T_ &point) const {
            return !Compare(point);
        }
 
        void Move(const T_ &x, const T_ &y) {
            this->Set({x, y});
        }
        
        typename T_::BaseType GetX() const {
            return this->Get().X;
        }
        
        void SetX(const typename T_::BaseType &value) {
            this->Set({value, this->Get().Y});
        }
        
        typename T_::BaseType GetY() const {
            return this->Get().Y;
        }
        
        void SetY(const typename T_::BaseType &value) {
            this->Set({this->Get().X, value});
        }
        
        NumericProperty<basic_PointProperty, typename T_::BaseType, &basic_PointProperty::GetX, &basic_PointProperty::SetX> X;
        NumericProperty<basic_PointProperty, typename T_::BaseType, &basic_PointProperty::GetY, &basic_PointProperty::SetY> Y;
    };
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void Translate(basic_PointProperty<C_, T_, Getter_, Setter_> &point, O_ x, O_ y) {
        auto p = point.Get();
        Translate(p, x, y);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void Translate(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const T_ &other) {
        auto p = point.Get();
        Translate(p, other);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void Scale(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O_ &size) {
        auto p = point.Get();
        Scale(p, size);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O1_, class O2_>
    void Scale(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O1_ &sizex, const O2_ &sizey) {
        auto p = point.Get();
        Scale(p, sizex, sizey);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void Scale(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O_ &size, const basic_Point<T_> &origin) {
        auto p = point.Get();
        Scale(p, size, origin);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O1_, class O2_>
    void Scale(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O1_ &sizex, const O2_ &sizey, const T_ &origin) {
        auto p = point.Get();
        Scale(p, sizex, sizey, origin);
        point.Set(p);
    }
 
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void Rotate(basic_PointProperty<C_, T_, Getter_, Setter_> &point, Float angle) {
        auto p = point.Get();
        Rotate(p, angle);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void Rotate(basic_PointProperty<C_, T_, Getter_, Setter_> &point, Float angle, const T_ &origin) {
        auto p = point.Get();
        Rotate(p, angle, origin);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void SkewX(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O_ &rate) {
        auto p = point.Get();
        SkewX(p, rate);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void SkewY(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O_ &rate) {
        auto p = point.Get();
        SkewY(p, rate);
        point.Set(p);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void SkewX(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O_ &rate, const T_ &origin) {
        point.X += T_((point.Y-origin.Y)*rate);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &), class O_>
    void SkewY(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const O_ &rate, const basic_Point<T_> &origin) {
        point.Y += T_((point.X-origin.X)*rate);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void ReflectX(basic_PointProperty<C_, T_, Getter_, Setter_> &point) {
        point.Y = -point.Y;
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void ReflectY(basic_PointProperty<C_, T_, Getter_, Setter_> &point) {
        point.X = -point.X;
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void HorizontalMirror(basic_PointProperty<C_, T_, Getter_, Setter_> &point) {
        ReflectX(point);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void VerticalMirror(basic_Point<T_> &point) {
        ReflectY(point);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void ReflectX(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const basic_Point<T_> &origin) {
        point.Y = -point.Y+origin.Y*2;
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void ReflectY(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const basic_Point<T_> &origin) {
        point.X = -point.X+origin.X*2;
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void HorizontalMirror(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const basic_Point<T_> &origin) {
        ReflectX(point, origin);
    }
 
    template<class C_, class T_, T_(C_::*Getter_)() const, void(C_::*Setter_)(const T_ &)>
    void VerticalMirror(basic_PointProperty<C_, T_, Getter_, Setter_> &point, const basic_Point<T_> &origin) {
        ReflectY(point, origin);
    }
 
    template<class C_, Point(C_::*Getter_)() const, void(C_::*Setter_)(const Point &)>
    using PointProperty = basic_PointProperty<C_, Point, Getter_, Setter_>;
    
    template<class C_, Pointf(C_::*Getter_)() const, void(C_::*Setter_)(const Pointf &)>
    using PointfProperty = basic_PointProperty<C_, Pointf, Getter_, Setter_>;
    
} }