27 {
29
32
33 constexpr TPoint() = default;
34
35 template <class U>
36 explicit constexpr TPoint(const TPoint<U>& other)
37 : TPoint(static_cast<
Type>(other.
x), static_cast<
Type>(other.
y)) {}
38
39 template <class U>
40 explicit constexpr TPoint(const TSize<U>& other)
43
45
46 static constexpr TPoint<Type> MakeXY(
Type x,
Type y) {
return {
x,
y}; }
47
48 template <class U>
49 static constexpr TPoint Round(const TPoint<U>& other) {
50 return TPoint{
static_cast<Type>(std::round(other.x)),
51 static_cast<Type>(std::round(other.y))};
52 }
53
54 constexpr bool operator==(
const TPoint& p)
const {
55 return p.x ==
x &&
p.y ==
y;
56 }
57
58 constexpr bool operator!=(
const TPoint& p)
const {
59 return p.x !=
x ||
p.y !=
y;
60 }
61
62 template <class U>
64 x +=
static_cast<Type>(
p.x);
65 y +=
static_cast<Type>(
p.y);
66 return *this;
67 }
68
69 template <class U>
71 x +=
static_cast<Type>(
s.width);
72 y +=
static_cast<Type>(
s.height);
73 return *this;
74 }
75
76 template <class U>
78 x -=
static_cast<Type>(
p.x);
79 y -=
static_cast<Type>(
p.y);
80 return *this;
81 }
82
83 template <class U>
85 x -=
static_cast<Type>(
s.width);
86 y -=
static_cast<Type>(
s.height);
87 return *this;
88 }
89
90 template <class U>
92 x *=
static_cast<Type>(
p.x);
93 y *=
static_cast<Type>(
p.y);
94 return *this;
95 }
96
97 template <class U>
99 x *=
static_cast<Type>(
s.width);
100 y *=
static_cast<Type>(
s.height);
101 return *this;
102 }
103
104 template <class U, class = std::enable_if_t<std::is_arithmetic_v<U>>>
108 return *this;
109 }
110
111 template <class U>
112 inline TPoint
operator/=(
const TPoint<U>& p) {
113 x /=
static_cast<Type>(
p.x);
114 y /=
static_cast<Type>(
p.y);
115 return *this;
116 }
117
118 template <class U>
120 x /=
static_cast<Type>(
s.width);
121 y /=
static_cast<Type>(
s.height);
122 return *this;
123 }
124
125 template <class U, class = std::enable_if_t<std::is_arithmetic_v<U>>>
129 return *this;
130 }
131
132 constexpr TPoint
operator-()
const {
return {-
x, -
y}; }
133
134 constexpr TPoint
operator+(
const TPoint& p)
const {
135 return {
x +
p.x,
y +
p.y};
136 }
137
138 template <class U>
139 constexpr TPoint
operator+(
const TSize<U>&
s)
const {
140 return {
x +
static_cast<Type>(
s.width),
y +
static_cast<Type>(
s.height)};
141 }
142
143 constexpr TPoint
operator-(
const TPoint& p)
const {
144 return {
x -
p.x,
y -
p.y};
145 }
146
147 template <class U>
148 constexpr TPoint
operator-(
const TSize<U>&
s)
const {
149 return {
x -
static_cast<Type>(
s.width),
y -
static_cast<Type>(
s.height)};
150 }
151
152 template <class U, class = std::enable_if_t<std::is_arithmetic_v<U>>>
155 }
156
157 constexpr TPoint
operator*(
const TPoint& p)
const {
158 return {
x *
p.x,
y *
p.y};
159 }
160
161 template <class U>
162 constexpr TPoint
operator*(
const TSize<U>&
s)
const {
163 return {
x *
static_cast<Type>(
s.width),
y *
static_cast<Type>(
s.height)};
164 }
165
166 template <class U, class = std::enable_if_t<std::is_arithmetic_v<U>>>
168 return {
static_cast<Type>(
x /
d),
static_cast<Type>(
y /
d)};
169 }
170
171 constexpr TPoint
operator/(
const TPoint& p)
const {
172 return {
x /
p.x,
y /
p.y};
173 }
174
175 template <class U>
176 constexpr TPoint
operator/(
const TSize<U>&
s)
const {
177 return {
x /
static_cast<Type>(
s.width),
y /
static_cast<Type>(
s.height)};
178 }
179
180 constexpr Type GetDistanceSquared(
const TPoint& p)
const {
183 return dx *
dx + dy * dy;
184 }
185
186 constexpr TPoint Min(const TPoint& p) const {
187 return {std::min<Type>(
x,
p.x), std::min<Type>(
y,
p.y)};
188 }
189
190 constexpr TPoint Max(const TPoint& p) const {
191 return {std::max<Type>(
x,
p.x), std::max<Type>(
y,
p.y)};
192 }
193
194 constexpr TPoint Floor()
const {
return {std::floor(
x), std::floor(
y)}; }
195
196 constexpr TPoint Ceil()
const {
return {std::ceil(
x), std::ceil(
y)}; }
197
198 constexpr TPoint Round()
const {
return {std::round(
x), std::round(
y)}; }
199
200 constexpr Type GetDistance(
const TPoint& p)
const {
201 return sqrt(GetDistanceSquared(p));
202 }
203
204 constexpr Type GetLengthSquared()
const {
return GetDistanceSquared({}); }
205
206 constexpr Type GetLength()
const {
return GetDistance({}); }
207
208 constexpr TPoint Normalize() const {
209 const auto length = GetLength();
211 return {1, 0};
212 }
214 }
215
216 constexpr TPoint Abs()
const {
return {std::fabs(
x), std::fabs(
y)}; }
217
218 constexpr Type Cross(
const TPoint& p)
const {
return (
x *
p.y) - (
y *
p.x); }
219
220 constexpr Type Dot(
const TPoint& p)
const {
return (
x *
p.x) + (
y *
p.y); }
221
222 constexpr TPoint Reflect(const TPoint& axis) const {
223 return *this - axis * this->Dot(axis) * 2;
224 }
225
226 constexpr Radians AngleTo(const TPoint& p) const {
227 return Radians{std::atan2(this->Cross(p), this->Dot(p))};
228 }
229
230 constexpr TPoint
Lerp(
const TPoint& p, Scalar t)
const {
231 return *
this + (
p - *
this) * t;
232 }
233
234 constexpr bool IsZero()
const {
return x == 0 &&
y == 0; }
235
237 IsFinite()
const {
return std::isfinite(
x) && std::isfinite(
y); }
238};
239
240
241
242template <class F, class I, class = MixedOp<F, I>>
243constexpr TPoint<F>
operator+(
const TPoint<F>& p1,
const TPoint<I>& p2) {
244 return {p1.x +
static_cast<F>(p2.x), p1.y +
static_cast<F>(p2.y)};
245}
246
247template <class F, class I, class = MixedOp<F, I>>
248constexpr TPoint<F>
operator+(
const TPoint<I>& p1,
const TPoint<F>& p2) {
249 return p2 + p1;
250}
251
252template <class F, class I, class = MixedOp<F, I>>
253constexpr TPoint<F>
operator-(
const TPoint<F>& p1,
const TPoint<I>& p2) {
254 return {p1.x -
static_cast<F>(p2.x), p1.y -
static_cast<F>(p2.y)};
255}
256
257template <class F, class I, class = MixedOp<F, I>>
258constexpr TPoint<F>
operator-(
const TPoint<I>& p1,
const TPoint<F>& p2) {
259 return {
static_cast<F>(p1.x) - p2.x,
static_cast<F>(p1.y) - p2.y};
260}
261
262template <class F, class I, class = MixedOp<F, I>>
263constexpr TPoint<F>
operator*(
const TPoint<F>& p1,
const TPoint<I>& p2) {
264 return {p1.x *
static_cast<F>(p2.x), p1.y *
static_cast<F>(p2.y)};
265}
266
267template <class F, class I, class = MixedOp<F, I>>
268constexpr TPoint<F>
operator*(
const TPoint<I>& p1,
const TPoint<F>& p2) {
269 return p2 * p1;
270}
271
272template <class F, class I, class = MixedOp<F, I>>
273constexpr TPoint<F>
operator/(
const TPoint<F>& p1,
const TPoint<I>& p2) {
274 return {p1.x /
static_cast<F>(p2.x), p1.y /
static_cast<F>(p2.y)};
275}
276
277template <class F, class I, class = MixedOp<F, I>>
278constexpr TPoint<F>
operator/(
const TPoint<I>& p1,
const TPoint<F>& p2) {
279 return {
static_cast<F>(p1.x) / p2.x,
static_cast<F>(p1.y) / p2.y};
280}
281
282
283
284template <class T, class U, class = std::enable_if_t<std::is_arithmetic_v<U>>>
285constexpr TPoint<T>
operator*(U
s,
const TPoint<T>& p) {
287}
288
289template <class T, class U, class = std::enable_if_t<std::is_arithmetic_v<U>>>
290constexpr TPoint<T>
operator/(U
s,
const TPoint<T>& p) {
291 return {
static_cast<T>(
s) /
p.x,
static_cast<T>(
s) /
p.y};
292}
293
294
295
296template <class T, class U>
297constexpr TPoint<T>
operator+(
const TSize<U>&
s,
const TPoint<T>& p) {
299}
300
301template <class T, class U>
302constexpr TPoint<T>
operator-(
const TSize<U>&
s,
const TPoint<T>& p) {
303 return {
static_cast<T>(
s.width) -
p.x,
static_cast<T>(
s.height) -
p.y};
304}
305
306template <class T, class U>
307constexpr TPoint<T>
operator*(
const TSize<U>&
s,
const TPoint<T>& p) {
309}
310
311template <class T, class U>
312constexpr TPoint<T>
operator/(
const TSize<U>&
s,
const TPoint<T>& p) {
313 return {
static_cast<T>(
s.width) /
p.x,
static_cast<T>(
s.height) /
p.y};
314}
315
316using Point = TPoint<Scalar>;
317using IPoint = TPoint<int64_t>;
321using Quad = std::array<Point, 4>;
322
323#undef ONLY_ON_FLOAT
324#undef ONLY_ON_FLOAT_M
325
326}
327
329
330template <class T>
331inline std::ostream&
operator<<(std::ostream& out,
333 out <<
"(" <<
p.x <<
", " <<
p.y <<
")";
335}
336
337}
338
339#endif
static SkSize operator*(SkISize u, SkScalar s)
bool operator!=(const sk_sp< T > &a, const sk_sp< U > &b)
bool operator==(const FlutterPoint &a, const FlutterPoint &b)
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE auto & d
#define ONLY_ON_FLOAT_M(Modifiers, Return)
skia_private::AutoTArray< sk_sp< SkImageFilter > > filters TypedMatrix matrix TypedMatrix matrix SkScalar dx
bool IsZero(char *begin, char *end)
constexpr Color operator-(T value, const Color &c)
constexpr Color operator/(T value, const Color &c)
constexpr Color operator+(T value, const Color &c)
TPoint< int32_t > IPoint32
TPoint< uint32_t > UintPoint32
std::array< Point, 4 > Quad
T Lerp(const T &a, const T &b, float t)
SINT Vec< N, T > & operator-=(Vec< N, T > &x, const Vec< N, T > &y)
SINT Vec< N, T > & operator*=(Vec< N, T > &x, const Vec< N, T > &y)
SIN Vec< N, float > sqrt(const Vec< N, float > &x)
SINT Vec< N, T > & operator/=(Vec< N, T > &x, const Vec< N, T > &y)
SINT Vec< N, T > & operator+=(Vec< N, T > &x, const Vec< N, T > &y)
std::ostream & operator<<(std::ostream &out, const impeller::Color &c)