← Back to branch summary

~marmuta/onboardosk/trunk

« back to all changes in this revision

Viewing changes to src/libonboardosk/tools/point_decl.h

  • Committer: marmuta
  • Date: 2017-08-23 22:00:55 UTC
  • mfrom: (0.1.25 onboardosk)
  • Revision ID: marmvta@gmail.com-20170823220055-4y6meaas01uct8wm
Attempt at reducing include dependencies. Marginally effective.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libonboardosk/tools/point_decl.h
 
1
#ifndef POINT_DECL_H
 
2
#define POINT_DECL_H
 
3
 
 
4
#include "point_fwd.h"
 
5
 
 
6
template<class T>
 
7
class TVec2
 
8
{
 
9
    public:
 
10
        TVec2() = default;
 
11
        TVec2(const TVec2<T>& v) = default;
 
12
        constexpr TVec2(T x_, T y_) noexcept:
 
13
            x(x_), y(y_)
 
14
        { }
 
15
 
 
16
 
 
17
        void operator=(const TVec2<T>& v)
 
18
        {
 
19
            x = v.x;
 
20
            y = v.y;
 
21
        }
 
22
 
 
23
        bool operator==(const TVec2<T>& v)
 
24
        {
 
25
            return x == v.x && y == v.y;
 
26
        }
 
27
 
 
28
        bool operator!=(const TVec2<T>& v)
 
29
        {
 
30
            return !operator==(v);
 
31
        }
 
32
 
 
33
        TVec2<T> floor() const;
 
34
 
 
35
        // squared euclidean length
 
36
        double length2()
 
37
        {
 
38
            return x * x + y * y;
 
39
        }
 
40
 
 
41
        // euclidean length
 
42
        double length();
 
43
 
 
44
        union {
 
45
            T x{};
 
46
            T w;
 
47
        };
 
48
        union {
 
49
            T y{};
 
50
            T h;
 
51
        };
 
52
};
 
53
typedef TVec2<double> Vec2;
 
54
typedef TVec2<int> Vec2Int;
 
55
 
 
56
 
 
57
template <typename T>
 
58
TVec2<T> operator+ (const TVec2<T>& v, const TVec2<T>& v2)
 
59
{ return TVec2<T>(v.w + v2.w, v.h + v2.h); }
 
60
template <typename T>
 
61
TVec2<T> operator+ (const TVec2<T>& v, const T& k)
 
62
{ return TVec2<T>(k + v.w, k + v.h); }
 
63
 
 
64
template <typename T>
 
65
void operator+= (TVec2<T>& v, const T& k)
 
66
{ v.x += k; v.y += k; }
 
67
template <typename T>
 
68
void operator+= (TVec2<T>& v, const TVec2<T>& v2)
 
69
{ v.x += v2.x; v.y += v2.y; }
 
70
 
 
71
template <typename T>
 
72
TVec2<T> operator- (const TVec2<T>& sz, const TVec2<T>& sz2)
 
73
{ return TVec2<T>(sz.w - sz2.w, sz.h - sz2.h); }
 
74
template <typename T>
 
75
TVec2<T> operator- (const TVec2<T>& sz, const T& k)
 
76
{ return TVec2<T>(sz.w - k, sz.h - k); }
 
77
template <typename T>
 
78
TVec2<T> operator- (const T& k, const TVec2<T>& sz)
 
79
{ return TVec2<T>(k - sz.w, k - sz.h); }
 
80
 
 
81
template <typename T>
 
82
TVec2<T> operator- (const TVec2<T>& sz)     // unary "-"
 
83
{ return TVec2<T>(-sz.w, -sz.h); }
 
84
 
 
85
template <typename T>
 
86
TVec2<T> operator* (const TVec2<T>& sz, const TVec2<T>& sz2)
 
87
{ return TVec2<T>(sz.w * sz2.w, sz.h * sz2.h); }
 
88
template <typename T>
 
89
TVec2<T> operator* (const TVec2<T>& sz, const T& k)
 
90
{ return TVec2<T>(k * sz.w, k * sz.h); }
 
91
 
 
92
template <typename T>
 
93
void operator*= (TVec2<T>& v, const T& k)
 
94
{ v.x *= k; v.y *= k; }
 
95
 
 
96
template <typename T>
 
97
TVec2<T> operator/ (const TVec2<T>& sz, const TVec2<T>& sz2)
 
98
{ return TVec2<T>(sz.w / sz2.w, sz.h / sz2.h); }
 
99
template <typename T>
 
100
TVec2<T> operator/ (const TVec2<T>& sz, const T& k)
 
101
{ return TVec2<T>(sz.w / k, sz.h / k); }
 
102
 
 
103
 
 
104
template<class T>
 
105
class TPoint : public TVec2<T> {
 
106
    public:
 
107
        TPoint() = default;
 
108
        constexpr TPoint(T x_, T y_) noexcept:
 
109
            TVec2<T>(x_, y_)
 
110
        { }
 
111
        TPoint(const TVec2<T>& v) :
 
112
            TVec2<T>(v)
 
113
        {}
 
114
 
 
115
        // squared euclidean distance
 
116
        double distance2(const TPoint& pt)
 
117
        {
 
118
            auto p = *this - pt;
 
119
            return p.x * p.x + p.y * p.y;
 
120
        }
 
121
};
 
122
typedef TPoint<double> Point;
 
123
typedef TPoint<int> PointInt;
 
124
 
 
125
 
 
126
template<class T>
 
127
class TSize : public TVec2<T> {
 
128
    public:
 
129
        TSize() = default;
 
130
        constexpr TSize(T x_, T y_) noexcept:
 
131
            TVec2<T>(x_, y_)
 
132
        { }
 
133
        TSize(const TVec2<T>& v) :
 
134
            TVec2<T>(v)
 
135
        {}
 
136
};
 
137
typedef TSize<double> Size;
 
138
typedef TSize<int> SizeInt;
 
139
 
 
140
 
 
141
template<class T>
 
142
class TOffset : public TVec2<T> {
 
143
    public:
 
144
        TOffset() = default;
 
145
        constexpr TOffset(T x_, T y_) noexcept:
 
146
            TVec2<T>(x_, y_)
 
147
        { }
 
148
        TOffset(const TVec2<T>& v) :
 
149
            TVec2<T>(v)
 
150
        {}
 
151
};
 
152
typedef TOffset<double> Offset;
 
153
typedef TOffset<int> OffsetInt;
 
154
 
 
155
 
 
156
template<class T>
 
157
class TScale : public TVec2<T> {
 
158
    public:
 
159
        TScale() = default;
 
160
        constexpr TScale(T x_, T y_) noexcept:
 
161
            TVec2<T>(x_, y_)
 
162
        { }
 
163
        TScale(const TVec2<T>& v) :
 
164
            TVec2<T>(v)
 
165
        {}
 
166
};
 
167
typedef TScale<double> Scale;
 
168
typedef TScale<int> ScaleInt;
 
169
 
 
170
 
 
171
template<class T>
 
172
class TLine {
 
173
    public:
 
174
        TLine() = default;
 
175
        constexpr TLine(TPoint<T> begin_, TPoint<T> end_) noexcept:
 
176
            begin(begin_), end(end_)
 
177
        { }
 
178
        TPoint<T> begin;
 
179
        TPoint<T> end;
 
180
};
 
181
typedef TLine<double> Line;
 
182
 
 
183
#endif // POINT_DECL_H