dl
dl_math.h
浏览该文件的文档.
1
10#pragma once
11
12#include <numeric>
13#include <list>
14#include <version>
15
16#include "dl_type.h"
17#include "io/dl_log.h"
18#include "base/dl_concept.h"
19#include "dl_algorithm.h"
20#include "dl_range.h"
21
22
23#include "system/dl_platform.h"
24#if (DL_PLATFORM == DL_PLATFORM_WIN32)
25#include <numbers>
26#endif
27
29namespace dl::Numbers
30{
31 constexpr Float EARTH_fADIUS = 6371.393_f;
32 constexpr Float GRAVITY = 9.8_f;
33 constexpr Float EULER = 2.718281828459045_f;
34 constexpr Float RATIO_GOLD = 0.618033988749894_f;
35}
36
38namespace dl::Numeric
39{
41 template<typename T, size_t N>
42 void Min(Array<T, N>& container)
43 {
44 for (size_t i = 0; i < N; ++i)
45 {
46 container[i] = (std::numeric_limits<T>::min)();
47 }
48 }
49 template<typename T, size_t N>
50 void Max(Array<T, N>& container)
51 {
52 for (size_t i = 0; i < N; ++i)
53 {
54 container[i] = (std::numeric_limits<T>::max)();
55 }
56 }
57}
58
64//void RectBinPack(const Size& size, list<>& map_fect, map<size_t, RectU>& map_fet)
65//{
66// //0按面积排序
67//}
68namespace dl::Math
69{
73template<typename T>
74constexpr bool IsOutRange(T x, T a, T b)
75{
76 return x < a || b < x;
77}
78
79
85template<typename T>
86constexpr T Pow(T x, T n)
87{
88 T ret = 1;
89 for (T i = 0; i < n; ++i)
90 {
91 ret *= x;
92 }
93 return ret;
94}
95constexpr uint64_t Pow64(uint64_t x, uint8_t n)
96{
97 uint64_t ret = 1;
98 for (uint8_t i = 0; i < n; ++i)
99 {
100 ret *= x;
101 }
102 return ret;
103}
104constexpr uint32_t Pow32(uint32_t x, uint8_t n)
105{
106 uint32_t ret = 1;
107 for (uint8_t i = 0; i < n; ++i)
108 {
109 ret *= x;
110 }
111 return ret;
112}
113
117constexpr uint64_t ARRAY_POW2[] = {
118 Pow64(2,0),Pow64(2,1),Pow64(2,2),Pow64(2,3),Pow64(2,4),Pow64(2,5),Pow64(2,6),Pow64(2,7),
119 Pow64(2,8),Pow64(2,9),Pow64(2,10),Pow64(2,11),Pow64(2,12),Pow64(2,13),Pow64(2,14),Pow64(2,15),
120 Pow64(2,16),Pow64(2,17),Pow64(2,18),Pow64(2,19),Pow64(2,20),Pow64(2,21),Pow64(2,22),Pow64(2,23),
121 Pow64(2,24),Pow64(2,25),Pow64(2,26),Pow64(2,27),Pow64(2,28),Pow64(2,29),Pow64(2,30),Pow64(2,31),
122 Pow64(2,32),Pow64(2,33),Pow64(2,34),Pow64(2,35),Pow64(2,36),Pow64(2,37),Pow64(2,38),Pow64(2,39),
123 Pow64(2,40),Pow64(2,41),Pow64(2,42),Pow64(2,43),Pow64(2,44),Pow64(2,45),Pow64(2,46),Pow64(2,47),
124 Pow64(2,48),Pow64(2,49),Pow64(2,50),Pow64(2,51),Pow64(2,52),Pow64(2,53),Pow64(2,54),Pow64(2,55),
125 Pow64(2,56),Pow64(2,57),Pow64(2,58),Pow64(2,59),Pow64(2,60),Pow64(2,61),Pow64(2,62),Pow64(2,63) };
126constexpr uint32_t ARRAY_POW2_32[] = {
127 Pow32(2,0),Pow32(2,1),Pow32(2,2),Pow32(2,3),Pow32(2,4),Pow32(2,5),Pow32(2,6),Pow32(2,7),
128 Pow32(2,8),Pow32(2,9),Pow32(2,10),Pow32(2,11),Pow32(2,12),Pow32(2,13),Pow32(2,14),Pow32(2,15),
129 Pow32(2,16),Pow32(2,17),Pow32(2,18),Pow32(2,19),Pow32(2,20),Pow32(2,21),Pow32(2,22),Pow32(2,23),
130 Pow32(2,24),Pow32(2,25),Pow32(2,26),Pow32(2,27),Pow32(2,28),Pow32(2,29),Pow32(2,30),Pow32(2,31) };
131
137#define DND_ARRAY_POW_LINE(index) if (x <= ARRAY_POW2[index])return ARRAY_POW2[index]
138constexpr uint64_t CeilToPow2(uint64_t&& x)
139{
148
149 log("数值过大,超过2^63:" + std::to_string(x));
150 return 0;
151}
152#define DND_ARRAY_POW_LINE_32(index) if (x <= ARRAY_POW2_32[index])return ARRAY_POW2_32[index]
163
168template <typename T>
169inline T CeilToPow2(const T& x)
170{
171#if (DL_PLATFORM == DL_PLATFORM_WIN32)
172 return std::bit_ceil(x);
173#else
174 return CeilToPow2(x);
175#endif
176}
177
178
185inline float RSqrt(float x)
186{
187 long i;
188 float x2, y;
189 const float threehalfs = 1.5f;
190
191 x2 = x * 0.5f;
192 y = x;
193 i = *(long*)&y;
194 i = 0x5f3759df - (i >> 1);
195 y = *(float*)&i;
196 y = y * (threehalfs - (x2 * y * y));
197 return y;
198}
199
200
204template<size_t N>
206{
207 float length = 0;
208 for (size_t i = 0; i < N; ++i)
209 {
210 length += (v[i] * v[i]);
211 }
212
213 length = RSqrt(length);
214 for (size_t i = 0; i < N; ++i)
215 {
216 v[i] *= length;
217 }
218}
219
220//-------------------------------有符号距离-----------------------------
225template <IsSigned T>
227{
228 return a[0] * a[0] + a[1] * a[1];
229}
230
231template <IsSigned T>
233{
234 return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
235}
236
237template <IsSigned T>
239{
240 return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
241}
242
247template <IsSigned T>
249{
250 return DistancePow2(b - a);
251}
252
253//-------------------------------无符号 加 有符号-----------------------------
257template <IsUnsigned T0, IsSigned T1>
258T0 AddU(T0 a, T1 b)
259{
260 if (b >= 0)
261 return a + (T0)b;
262 T0 nag_b = (T0)-b;
263 return nag_b < a ? a - nag_b : 0;
264}
265
268template <IsUnsigned T0, IsSigned T1, size_t N>
270{
271 for (size_t i = 0; i < N; ++i)
272 a[i] = AddU(a[i], b[i]);
273}
274
275template <IsUnsigned T0, IsSigned T1, size_t N>
276[[nodiscard]]
278{
279 Array<T0, N> ret = a;
280 for (size_t i = 0; i < N; ++i)
281 AddU(ret, b[i]);
282 return ret;
283}
284
287template <IsUnsigned T0, IsSigned T1>
288bool AddUCheck(T0 a, T1 b, T0& ret)
289{
290 if (b >= 0)
291 return a + (T0)b;
292 T0 nag_b = (T0)-b;
293 if (nag_b > a)
294 return false;
295 ret = a - nag_b;
296 return true;
297}
298
301template <IsUnsigned T0, IsSigned T1, size_t N>
302bool AddUCheck(const Array<T0, N>& a, const Array<T1, N>& b, const Array<T0, N>& ret)
303{
304 for (size_t i = 0; i < N; ++i)
305 {
306 if (!AddUCheck(a[i], b[i], ret[i]))
307 return false;
308 }
309 return true;
310}
311//-------------------------------无符号操作-----------------------------
315template <IsUnsigned T>
316T SubU(T a, T b)
317{
318 return a > b ? a - b : 0;
319}
320
323template <IsUnsigned T0, IsSigned T1>
324T0 SubU(T0 a, T1 b)
325{
326 if (b <= 0)
327 return a + -b;
328 return SubU(a, (T0)b);
329}
330
333template <IsUnsigned T, size_t N>
335{
336 Array<T, N> ret;
337 for (size_t i = 0; i < N; ++i)
338 ret[i] = SubU(a[i], b[i]);
339 return ret;
340}
341
344template <IsUnsigned T0, IsSigned T1, size_t N>
346{
347 Array<T0, N> ret;
348 for (size_t i = 0; i < N; ++i)
349 ret[i] = SubU(a[i], b[i]);
350 return ret;
351}
352//---------------------------------无符号距离----------------------------------------
356template <IsUnsigned T>
357T DisU(T a, T b)
358{
359 return a < b ? b - a : a - b;
360}
361
365template <IsUnsigned T, size_t N>
367{
368 Array<T, N> ret;
369 for (size_t i = 0; i < N; ++i)
370 ret[i] = DisU(a[i], b[i]);
371 return ret;
372}
373
374
379template <IsUnsigned T>
381{
382 unsigned dx = DisU(a[0], b[0]);
383 unsigned dy = DisU(a[1], b[1]);
384 return dx * dx + dy * dy;
385}
386template <IsUnsigned T>
388{
389 return static_cast<T>(std::sqrt(DistancePow2U(a, b)));
390}
391
394template <IsSigned T, size_t N>
396{
397 T length = DistancePow2(v);
398 length = sqrt(length);
399
400 v /= length;
401}
402
403template <IsSigned T, size_t N>
404[[nodiscard]]
406{
407 Array<T, N> ret = v;
408 Normalize(ret);
409 return ret;
410}
411
416std::vector<PointU> GetCircle(const Size& size, const PointU& xy, unsigned rad);
421std::vector<Point> GetCircle(const Point& xy, unsigned rad);
422
423
429constexpr double PI(unsigned n = 1, unsigned d = 1)
430{
431#ifdef false
432 return std::numbers::pi * n / d;
433#else
434 return 3.1415926535897932384626433832795 * n / d;
435#endif
436}
437
441/*dnd::Direction IndexRpg2Direction(size_t index)
442{
443 if (index == 0)
444 return Direction::DOWN;
445 if (index == 1)
446 return Direction::LEFT;
447 if (index == 2)
448 return Direction::RIGHT;
449 if (index == 3)
450 return Direction::UP;
451
452 debug_warn("错误的下标![0, 3]");
453 return Direction::DOWN;
454}*/
455
459//DirectionMask::Var Dir2Mask(const Vector2& dir)
460//{
461// if (Every::Zero(dir))
462// return DirectionMask::NONE;
463// double r = atan2(dir[1], dir[0]);//返回(-pi, pi],从正x轴向正y轴旋转
464// if (r < 0)//变换到(0, 2pi],x轴不变
465// r += (std::numbers::pi * 2.0);
466// r += (std::numbers::pi / 8.0);//四舍五入 加pi/8
467// size_t index = r / (std::numbers::pi / 4.0);//2pi分为8个方向为pi/4
468
469// dnd_assert(index >= 0 && index <= 7);
470// //x为0
471// if (index == 0)
472// return DirectionMask::RIGHT;
473// else if (index == 1)
474// return DirectionMask::RIGHT_DOWN;
475// else if (index == 2)
476// return DirectionMask::DOWN;
477// else if (index == 3)
478// return DirectionMask::LEFT_DOWN;
479// else if (index == 4)
480// return DirectionMask::LEFT;
481// else if (index == 5)
482// return DirectionMask::LEFT_UP;
483// else if (index == 6)
484// return DirectionMask::UP;
485// else if (index == 7)
486// return DirectionMask::RIGHT_UP;
487// return DirectionMask::NONE;
488//}
489
495template<IsReal T>
496constexpr T AlignF(T x, T align)
497{
498 assert(align > 0);
499
500 if (x < 0)
501 {
502 T ret = -align;
503 while (x < ret)
504 {
505 ret -= align;
506 }
507 return ret + align;
508 }
509 else
510 {
511 T ret = align;
512 while (x > ret)
513 {
514 ret += align;
515 }
516 return ret;
517 }
518}
519
524template<IsUnsigned T>
525constexpr T Align(T x, T align)
526{
527 assert(align != 0);
528
529 T ret = align;
530 while (x > ret)
531 {
532 ret += align;
533 }
534 return ret;
535}
536
540constexpr unsigned IsPow2(unsigned x)
541{
542 return x && !(x & (x - 1));
543}
544
549constexpr unsigned AlignPow2(unsigned x, unsigned align)
550{
551 if (!IsPow2(align))
552 return 0;
553
554 return (x + align - 1) & ~(align - 1);
555}
556
562constexpr unsigned div_found(unsigned n, unsigned d)
563{
564 unsigned q = n / d;
565 unsigned r = n % d;
566 return r >= (d >> 1) ? q + 1 : q;
567}
568
575constexpr unsigned div_found_fast(unsigned n, unsigned d)
576{
577 return (n + (d >> 1)) / d;
578}
579
591constexpr float OffsetOrder(float order, int u = 1, int v = 0, int w = 0)
592{
593 constexpr int NUM_ORDER_DT = 100;
594 float ret = order + (w + v * NUM_ORDER_DT + u * NUM_ORDER_DT * NUM_ORDER_DT)
595 * std::numeric_limits<float>::epsilon();
596 if (!is_saturate(ret))
597 {
598 log_("order超出范围:{}", ret);
599 return saturate(ret);
600 }
601 return ret;
602}
603
606constexpr Float CrossProduct(const Position2& a, const Position2& b)
607{
608 return a[0] * b[1] - a[1] * b[0];
609}
610
611constexpr Position3 CrossProduct(const Position3& a, const Position3& b)
612{
613 return {
614 a[1] * b[2] - b[1] * a[2],
615 a[2] * b[0] - b[2] * a[0],
616 a[0] * b[1] - b[0] * a[1]
617 };
618}
619
623template<typename T, size_t N>
624constexpr T DotProduct(const Array<T, N>& a, const Array<T, N>& b)
625{
626 T ret = 0;
627 for (size_t i = 0; i < N; ++i)
628 ret += a[i] * b[i];
629 return ret;
630}
631
636Position4 Slerp(const Position4& q0, const Position4& q1, const Float& t);
637
641//constexpr void Rect2Uv(const Size& tex_size, const RectU& rect, floatx2* uv)
642//{
643// floatx4 ltrb;
644// ltrb[LTRB::LEFT] = float(rect[LTRB::LEFT]) / tex_size[0];
645// ltrb[LTRB::TOP] = float(rect[LTRB::TOP]) / tex_size[1];
646// ltrb[LTRB::RIGHT] = float(rect[LTRB::RIGHT]) / tex_size[0];
647// ltrb[LTRB::BUTTOM] = float(rect[LTRB::BUTTOM]) / tex_size[1];
648//
649//
650// uv[Corner::LT] = { ltrb[LTRB::LEFT], ltrb[LTRB::TOP] };
651// uv[Corner::RT] = { ltrb[LTRB::RIGHT], ltrb[LTRB::TOP] };
652// uv[Corner::LB] = { ltrb[LTRB::LEFT], ltrb[LTRB::BUTTOM] };
653// uv[Corner::RB] = { ltrb[LTRB::RIGHT], ltrb[LTRB::BUTTOM] };
654//}
655
659template<typename C>
660constexpr auto DistanceDiagonal(const C& p0, const C& p1)
661{
662 C dt = p1 - p0;
663 Every::Abs(dt);
664 return Select::Max(dt);
665}
666
667
671std::vector<Point> DrawLineLerp(const Point& p0, const Point& p1);
672
676std::vector<Point> DrawLineBresenham(const Point& p0, const Point& p1);
677
682std::vector<Point> DrawLineOrth(const Point& p0, const Point& p1);
683
688std::vector<Point> DrawLineCover(const Point& p0, const Point& p1);
689
694void MergePath(std::list<Point>& list_pos);
695
700template<typename F>
701void MergePathDirect(std::list<Point>& list_pos, F func_pass)
702{
703 if (list_pos.size() < 3)
704 return;
705 auto iter_last = list_pos.end();//最后一个点总是有效的
706 --iter_last;
707 for (auto iter_0 = list_pos.begin(); iter_0 != iter_last;)
708 {//直到前一个点到 iter_last(最后一个点)
709 //iter_0的下一个点
710 auto iter_0_next = iter_0;
711 ++iter_0_next;
712 //是否删除了节点
713 bool b_del = false;
714 for (auto iter_1 = iter_last; iter_1 != iter_0_next; --iter_1)
715 {//后一个点 从后往前遍历,直到iter_0_next
716 if (func_pass(*iter_0, *iter_1))
717 {//如果可通行 删除中间的节点
718 for (auto iter = iter_0_next; iter != iter_1;)
719 iter = list_pos.erase(iter);
720 iter_0 = iter_1;//后一个点此时成为起点
721 b_del = true;
722 break;
723 }
724 }
725 if (!b_del)
726 ++iter_0;
727 }
728}
729
730
731//----------------Quad和Rect的操作不同,Quad需要加名字-------
735template<typename T>
736constexpr T GetQuadSize(const Array<T, 4>& quad)
737{
738 return quad[2] - quad[0];
739}
740
745template<typename T>
747{
748 return { quad[0], quad[1], quad[2] };
749}
750template<typename T>
752{
753 return { quad[0], quad[2], quad[3] };
754}
755
761template<typename T>
762constexpr bool IsRectValid(const Array<T, 4>& rect)
763{
764 return rect[0] <= rect[2]
765 && rect[1] <= rect[3];
766}
767
771template<typename T>
772constexpr bool IsRectEmpty(const Array<T, 4>& rect)
773{
774 return rect[0] == rect[2]
775 && rect[1] == rect[3];
776}
777
782template<typename T>
783constexpr bool IsRectInSize(const Array<T, 4>& rect, const Size& size)
784{
785 if (!IsRectValid(rect))
786 return false;
787 return rect[0] >= 0
788 && rect[1] >= 0
789 && rect[2] <= size[0]
790 && rect[3] <= size[1];
791}
792
796constexpr bool IsXyInSize(const Point& xy, const Size& size)
797{
798 if (Each::Less(xy, {}))
799 return false;
800 return unsigned(xy[0]) < size[0]
801 && unsigned(xy[1]) < size[1];
802}
803
808constexpr bool IsXyInRect(const Point& xy, const Rect& rect)
809{
810 return xy[0] >= rect[0]
811 && xy[1] >= rect[1]
812 && xy[0] < rect[2]
813 && xy[1] < rect[3];
814}
815
819constexpr bool IsTriangle(const Triangle& triangle)
820{
821 Position ab = triangle[0] - triangle[1];
822 Position ac = triangle[0] - triangle[2];
823
824 return CrossProduct(ab, ac) != 0;
825}
826
832constexpr bool IsDotInTriangle(const Position& dot, const Triangle& triangle)
833{
834 if (!IsTriangle(triangle))
835 return false;
836 Position pa = triangle[0] - dot;
837 Position pb = triangle[1] - dot;
838 Position pc = triangle[2] - dot;
839 Float t1 = CrossProduct(pa, pb);
840 Float t2 = CrossProduct(pb, pc);
841 Float t3 = CrossProduct(pc, pa);
842 return t1 * t2 >= 0 &&
843 t1 * t3 >= 0 &&
844 t2 * t3 >= 0;
845}
846
852constexpr bool IsDotInQuad(const Position& dot, const Quad& quad)
853{
854 return Math::IsDotInTriangle(dot, GetQuadTriangle0(quad))
856}
857
863//constexpr bool IsDotInQuadConvex(const Position& dot, const Quad& quad)
864//{
865//
866//}
867
872{
873 return { w, w * Numbers::RATIO_GOLD };
874}
875
876}
用于模板限定,更好的报错信息
日志系统
#define log_(...)
#define DND_ARRAY_POW_LINE_32(index)
#define DND_ARRAY_POW_LINE(index)
向上取2的幂次
平台宏
范围操作
通用类型
constexpr bool Less(const Array< T, N > &a, const Array< T, N > &b)
每个元素都小于返回真
void Abs(C &c)
取绝对值
2维装箱算法
T SubU(T a, T b)
无符号类型相减,负数转为0
constexpr unsigned IsPow2(unsigned x)
是否2的幂
std::vector< Point > DrawLineOrth(const Point &p0, const Point &p1)
正交 画线算法
constexpr bool IsXyInRect(const Point &xy, const Rect &rect)
判断 点是否在矩形内
constexpr uint64_t Pow64(uint64_t x, uint8_t n)
T DistancePow2U(const Array< T, 2 > &a, const Array< T, 2 > &b)
返回 距离的平方
constexpr bool IsOutRange(T x, T a, T b)
判断数值是否越界(前闭后开)
constexpr T Align(T x, T align)
对齐align的倍数
constexpr Float CrossProduct(const Position2 &a, const Position2 &b)
叉乘
constexpr bool IsTriangle(const Triangle &triangle)
判断是否三角形
constexpr unsigned AlignPow2(unsigned x, unsigned align)
对齐align的倍数
constexpr Position CreatePositionByRatioGoldW(Float w)
判断点是否在凸四边形内
constexpr float OffsetOrder(float order, int u=1, int v=0, int w=0)
偏移order
std::vector< Point > DrawLineLerp(const Point &p0, const Point &p1)
线性插值 画线算法
void MergePathDirect(std::list< Point > &list_pos, F func_pass)
路径合并(网格路径)
constexpr uint32_t ARRAY_POW2_32[]
constexpr T AlignF(T x, T align)
RGP资源下标转方向
std::vector< PointU > GetCircle(const Size &size, const PointU &xy, unsigned rad)
返回圆形范围的节点,考虑越界
constexpr unsigned div_found(unsigned n, unsigned d)
无符号除法,返回四舍五入结果
constexpr bool IsRectEmpty(const Array< T, 4 > &rect)
判断 矩形 是否空
constexpr bool IsXyInSize(const Point &xy, const Size &size)
判断 点是否在大小内
constexpr T GetQuadSize(const Array< T, 4 > &quad)
返回 Quad 的大小
constexpr uint32_t Pow32(uint32_t x, uint8_t n)
constexpr T Pow(T x, T n)
返回x的n次方
bool AddUCheck(T0 a, T1 b, T0 &ret)
无符号 加 有符号,检查负数
std::vector< Point > DrawLineCover(const Point &p0, const Point &p1)
覆盖 画线算法
void Normalize(Array< T, N > &v)
向量单位化
constexpr unsigned div_found_fast(unsigned n, unsigned d)
无符号除法,返回四舍五入结果
constexpr Array< T, 3 > GetQuadTriangle0(const Array< T, 4 > &quad)
返回 Quad的三角形
Position4 Slerp(const Position4 &q0, const Position4 &q1, const Float &t)
球面线性插值
constexpr double PI(unsigned n=1, unsigned d=1)
返回PI的分数
void MergePath(std::list< Point > &list_pos)
路径合并(网格路径)
float RSqrt(float x)
返回平方根的倒数
T DisU(T a, T b)
返回无符号类型的差值
void NormalizeFast(Array< float, N > &v)
向量单位化,精度低速度快
constexpr uint64_t ARRAY_POW2[]
2的整数次幂列表
T DistancePow2(const Array< T, 2 > &a)
返回 向量 距离的平方
std::vector< Point > DrawLineBresenham(const Point &p0, const Point &p1)
bresenham 画线算法
constexpr auto DistanceDiagonal(const C &p0, const C &p1)
纹理区域转uv
constexpr T DotProduct(const Array< T, N > &a, const Array< T, N > &b)
点乘
constexpr bool IsDotInQuad(const Position &dot, const Quad &quad)
判断点是否在四边形内(包含边)
constexpr uint64_t CeilToPow2(uint64_t &&x)
constexpr Array< T, 3 > GetQuadTriangle1(const Array< T, 4 > &quad)
T DistanceU(const Array< T, 2 > &a, const Array< T, 2 > &b)
constexpr bool IsRectValid(const Array< T, 4 > &rect)
判断 矩形 是否有效
constexpr bool IsRectInSize(const Array< T, 4 > &rect, const Size &size)
判断 矩形 在 大小 内,首先它必须是有效的矩形
T0 AddU(T0 a, T1 b)
无符号 加 有符号,防止小于0
constexpr bool IsDotInTriangle(const Position &dot, const Triangle &triangle)
判断点是否在三角形内(包含边)
类似std::numbers的常数
constexpr Float EULER
自然常数
constexpr Float EARTH_fADIUS
地球半径km
constexpr Float GRAVITY
地球重力加速度(赤道最小)
constexpr Float RATIO_GOLD
黄金比例
类似numeric头文件的数值操作
void Min(Array< T, N > &container)
返回的是最小正数(假设有符号)
void Max(Array< T, N > &container)
constexpr auto Max(const C &container)
返回容器最大值
Position2 Position
float Float
Array< Float, 2 > Position2
constexpr T is_saturate(const T &x)
是否数值在[0, 1]
Array< Position, 3 > Triangle
Point2U PointU
void log(std::string_view str, const std::source_location location=std::source_location::current())
以当前设置输出
Array< Float, 3 > Position3
Array< Float, 4 > Position4
constexpr T saturate(const T &x)
限制数值到 [0, 1]
Point4 Rect
Array< Position, 4 > Quad
PointU Size
Point2 Point