1 | // This file is a part of Framsticks SDK. http://www.framsticks.com/ |
---|
2 | // Copyright (C) 1999-2015 Maciej Komosinski and Szymon Ulatowski. |
---|
3 | // See LICENSE.txt for details. |
---|
4 | |
---|
5 | #ifndef _2D_H_ |
---|
6 | #define _2D_H_ |
---|
7 | |
---|
8 | #include "nonstd_stl.h" |
---|
9 | #include <math.h> |
---|
10 | |
---|
11 | //unifikacja starych GUIXY i Pt2D |
---|
12 | template <typename T> class XY |
---|
13 | { |
---|
14 | public: |
---|
15 | T x,y; |
---|
16 | XY() {} |
---|
17 | XY(T _x,T _y):x(_x),y(_y) {} |
---|
18 | template <typename Q> XY(const Q& other):x(other.x),y(other.y) {} |
---|
19 | template <typename Q> const XY& operator=(const Q& other) {x=other.x; y=other.y; return *this;} |
---|
20 | template <typename Q> const XY operator()(const Q& other) {return XY(other.x,other.y);} |
---|
21 | XY operator+(const XY&p) const {return XY(x+p.x,y+p.y);} |
---|
22 | XY operator-(const XY&p) const {return XY(x-p.x,y-p.y);} |
---|
23 | XY operator+=(const XY&p) {x+=p.x; y+=p.y; return *this;} |
---|
24 | XY operator-=(const XY&p) {x-=p.x; y-=p.y; return *this;} |
---|
25 | XY operator-() const {return XY(-x,-y);} |
---|
26 | XY operator*=(T q) {x*=q; y*=q; return *this;} |
---|
27 | XY operator/=(T q) {x/=q; y/=q; return *this;} |
---|
28 | XY operator/(T q) {return XY(x/q,y/q);} |
---|
29 | XY operator*(T q) const {return XY(q*x,q*y);} |
---|
30 | void set(T _x,T _y) {x=_x; y=_y;} |
---|
31 | void add(T _x,T _y) {x+=_x; y+=_y;} |
---|
32 | void sub(T _x,T _y) {x-=_x; y-=_y;} |
---|
33 | bool operator==(const XY& p) const {return (fabs(double(x-p.x))<1e-20)&&(fabs(double(y-p.y))<1e-20);} |
---|
34 | T distanceTo(const XY& p) const {return sqrt(double((p.x-x)*(p.x-x)+(p.y-y)*(p.y-y)));} |
---|
35 | T magnitude() const {return sqrt(x*x+y*y);} |
---|
36 | T length() const {return sqrt(x*x+y*y);} |
---|
37 | T lengthSq() const { return x*x + y*y; } |
---|
38 | T dotProduct(const XY& v) const {return x*v.x + y*v.y;} |
---|
39 | T crossProduct(const XY& v) const {return x*v.y - y*v.x;} |
---|
40 | void normalize() { operator/=(length()); } // length becomes 1 |
---|
41 | static XY average(const XY& v1,const XY& v2) { return XY((v1.x+v2.x)*0.5,(v1.y+v2.y)*0.5); } |
---|
42 | double getDirection() const {return atan2(y,x);} |
---|
43 | static XY interpolate(const XY& v1, const XY& v2,double t) {return v1+(v2-v1)*t;} |
---|
44 | XY toInt() const {return XY(int(x),int(y));} |
---|
45 | static const XY& zero() {static XY t(0,0); return t;} |
---|
46 | static const XY& one() {static XY t(1,1); return t;} |
---|
47 | }; |
---|
48 | |
---|
49 | template <typename T> XY<T> xymin(const XY<T>& a, const XY<T>& b) {return XY<T>(min(a.x,b.x),min(a.y,b.y));} |
---|
50 | template <typename T> XY<T> xymax(const XY<T>& a, const XY<T>& b) {return XY<T>(max(a.x,b.x),max(a.y,b.y));} |
---|
51 | |
---|
52 | template <typename T> |
---|
53 | class XYMargin |
---|
54 | { |
---|
55 | public: |
---|
56 | XYMargin(T x=0):left(x),top(x),right(x),bottom(x) {} |
---|
57 | XYMargin(T l,T t,T r,T b):left(l),top(t),right(r),bottom(b) {} |
---|
58 | T left,top,right,bottom; |
---|
59 | void operator=(T x) {left=top=right=bottom=x;} |
---|
60 | XYMargin operator-() const {return XYMargin(-left,-top,-right,-bottom);} |
---|
61 | void operator=(const XYMargin<T> &other) {left=other.left; top=other.top; right=other.right; bottom=other.bottom;} |
---|
62 | T horizontal() const {return left+right;} |
---|
63 | T vertical() const {return top+bottom;} |
---|
64 | }; |
---|
65 | |
---|
66 | template <typename T> |
---|
67 | class XYRect |
---|
68 | { |
---|
69 | public: |
---|
70 | XY<T> p,size; |
---|
71 | XYRect() {} |
---|
72 | XYRect(const XY<T>& p1,const XY<T>& s):p(p1),size(s) {} |
---|
73 | template <typename Q> XYRect(const Q& other):p(other.p),size(other.size) {} |
---|
74 | XYRect(T _x,T _y,T _w,T _h):p(_x,_y),size(_w,_h) {} |
---|
75 | static XYRect<T> centeredAt(const XY<T>& p,XY<T> s) {return XYRect<T>(p-s*0.5,s);} |
---|
76 | |
---|
77 | bool isEmpty() const {return (size.x<0)||(size.y<0);} |
---|
78 | XYRect toInt() const {return XYRect(int(p.x),int(p.y),int(p.x+size.x)-int(p.x),int(p.y+size.y)-int(p.y));} |
---|
79 | bool operator==(const XYRect& r) const {return (p==r.p) && (size==r.size);} |
---|
80 | template <typename Q> const XYRect& operator=(const Q& other) {p=other.p; size=other.size; return *this;} |
---|
81 | |
---|
82 | bool intersects(const XYRect& r) const |
---|
83 | { |
---|
84 | if (r.p.x >= (p.x+size.x)) return false; |
---|
85 | if (r.p.y >= (p.y+size.y)) return false; |
---|
86 | if ((r.p.x+r.size.x) <= p.x) return false; |
---|
87 | if ((r.p.y+r.size.y) <= p.y) return false; |
---|
88 | return true; |
---|
89 | } |
---|
90 | |
---|
91 | bool contains(const XY<T>& n) const |
---|
92 | { |
---|
93 | if (n.x<p.x) return false; |
---|
94 | if (n.x>(p.x+size.x)) return false; |
---|
95 | if (n.y<p.y) return false; |
---|
96 | if (n.y>(p.y+size.y)) return false; |
---|
97 | return true; |
---|
98 | } |
---|
99 | |
---|
100 | void add(const XY<T>& n) |
---|
101 | { |
---|
102 | if (n.x<p.x) {size.x+=p.x-n.x; p.x=n.x;} |
---|
103 | else if (n.x>(p.x+size.x)) size.x=n.x-p.x; |
---|
104 | if (n.y<p.y) {size.y+=p.y-n.y; p.y=n.y;} |
---|
105 | else if (n.y>(p.y+size.y)) size.y=n.y-p.y; |
---|
106 | } |
---|
107 | |
---|
108 | XYRect extendBy(const XY<T>& border_size) const |
---|
109 | { |
---|
110 | return XYRect(p-border_size,size+border_size*2); |
---|
111 | } |
---|
112 | |
---|
113 | XYRect shrinkBy(const XY<T>& border_size) const |
---|
114 | { |
---|
115 | return XYRect(p+border_size,size-border_size*2); |
---|
116 | } |
---|
117 | |
---|
118 | XYRect extendBy(const XYMargin<T>& m) const |
---|
119 | { |
---|
120 | return XYRect(p.x-m.left,p.y-m.top,size.x+m.horizontal(),size.y+m.vertical()); |
---|
121 | } |
---|
122 | |
---|
123 | XYRect shrinkBy(const XYMargin<T>& m) const |
---|
124 | { |
---|
125 | return XYRect(p.x+m.left,p.y+m.top,size.x-m.horizontal(),size.y-m.vertical()); |
---|
126 | } |
---|
127 | |
---|
128 | XYMargin<T> marginTowards(const XYRect &r) const |
---|
129 | { |
---|
130 | return XYMargin<T>(r.p.x, r.p.y, |
---|
131 | (p.x+size.x)-(r.p.x+r.size.x), (p.y+size.y)-(r.p.y+r.size.y)); |
---|
132 | } |
---|
133 | |
---|
134 | XYRect intersection(const XYRect& r) const |
---|
135 | { |
---|
136 | XYRect i; |
---|
137 | XY<T> p2=p+size; |
---|
138 | XY<T> rp2=r.p+r.size; |
---|
139 | i.p.x=max(p.x,r.p.x); |
---|
140 | i.p.y=max(p.y,r.p.y); |
---|
141 | i.size.x=min(p2.x,rp2.x)-i.p.x; |
---|
142 | i.size.y=min(p2.y,rp2.y)-i.p.y; |
---|
143 | return i; |
---|
144 | } |
---|
145 | |
---|
146 | XYRect translation(const XY<T>& t) const |
---|
147 | { |
---|
148 | return XYRect(p+t,size); |
---|
149 | } |
---|
150 | |
---|
151 | T distanceTo(const XY<T>& n) const |
---|
152 | { |
---|
153 | XY<T> tp=n; |
---|
154 | if (n.x<p.x) tp.x=p.x; else if (n.x>=(p.x+size.x)) tp.x=p.x+size.x; |
---|
155 | if (n.y<p.y) tp.y=p.y; else if (n.y>=(p.y+size.y)) tp.y=p.y+size.y; |
---|
156 | return tp.distanceTo(n); |
---|
157 | } |
---|
158 | |
---|
159 | static const XYRect& zero() {static XYRect t(0,0,0,0); return t;} |
---|
160 | static const XYRect& one() {static XYRect t(0,0,1,1); return t;} |
---|
161 | }; |
---|
162 | |
---|
163 | typedef XY<int> IntXY; |
---|
164 | typedef XYRect<int> IntRect; |
---|
165 | |
---|
166 | #endif |
---|