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}
252template <typename T>
254{
255 return static_cast<T>(std::sqrt(DistancePow2(a)));
256}
257template <typename T>
259{
260 return static_cast<T>(std::sqrt(DistancePow2(a, b)));
261}
262//-------------------------------无符号 加 有符号-----------------------------
266template <IsUnsigned T0, IsSigned T1>
267T0 AddU(T0 a, T1 b)
268{
269 if (b >= 0)
270 return a + (T0)b;
271 T0 nag_b = (T0)-b;
272 return nag_b < a ? a - nag_b : 0;
273}
274
277template <IsUnsigned T0, IsSigned T1, size_t N>
279{
280 for (size_t i = 0; i < N; ++i)
281 a[i] = AddU(a[i], b[i]);
282}
283
284template <IsUnsigned T0, IsSigned T1, size_t N>
285[[nodiscard]]
287{
288 Array<T0, N> ret = a;
289 for (size_t i = 0; i < N; ++i)
290 AddU(ret, b[i]);
291 return ret;
292}
293
296template <IsUnsigned T0, IsSigned T1>
297bool AddUCheck(T0 a, T1 b, T0& ret)
298{
299 if (b >= 0)
300 return a + (T0)b;
301 T0 nag_b = (T0)-b;
302 if (nag_b > a)
303 return false;
304 ret = a - nag_b;
305 return true;
306}
307
310template <IsUnsigned T0, IsSigned T1, size_t N>
311bool AddUCheck(const Array<T0, N>& a, const Array<T1, N>& b, const Array<T0, N>& ret)
312{
313 for (size_t i = 0; i < N; ++i)
314 {
315 if (!AddUCheck(a[i], b[i], ret[i]))
316 return false;
317 }
318 return true;
319}
320//-------------------------------无符号操作-----------------------------
324template <IsUnsigned T>
325T SubU(T a, T b)
326{
327 return a > b ? a - b : 0;
328}
329
332template <IsUnsigned T0, IsSigned T1>
333T0 SubU(T0 a, T1 b)
334{
335 if (b <= 0)
336 return a + -b;
337 return SubU(a, (T0)b);
338}
339
342template <IsUnsigned T, size_t N>
344{
345 Array<T, N> ret;
346 for (size_t i = 0; i < N; ++i)
347 ret[i] = SubU(a[i], b[i]);
348 return ret;
349}
350
353template <IsUnsigned T0, IsSigned T1, size_t N>
355{
356 Array<T0, N> ret;
357 for (size_t i = 0; i < N; ++i)
358 ret[i] = SubU(a[i], b[i]);
359 return ret;
360}
361//---------------------------------无符号距离----------------------------------------
365template <IsUnsigned T>
366T DisU(T a, T b)
367{
368 return a < b ? b - a : a - b;
369}
370
374template <IsUnsigned T, size_t N>
376{
377 Array<T, N> ret;
378 for (size_t i = 0; i < N; ++i)
379 ret[i] = DisU(a[i], b[i]);
380 return ret;
381}
382
383
388template <IsUnsigned T>
390{
391 unsigned dx = DisU(a[0], b[0]);
392 unsigned dy = DisU(a[1], b[1]);
393 return dx * dx + dy * dy;
394}
395template <IsUnsigned T>
397{
398 return static_cast<T>(std::sqrt(DistancePow2U(a, b)));
399}
400
403template <IsSigned T, size_t N>
405{
406 T length = DistancePow2(v);
407 length = sqrt(length);
408
409 v /= length;
410}
411
412template <IsSigned T, size_t N>
413[[nodiscard]]
415{
416 Array<T, N> ret = v;
417 Normalize(ret);
418 return ret;
419}
420
425std::vector<PointU> GetCircle(const Size& size, const PointU& xy, unsigned rad);
430std::vector<Point> GetCircle(const Point& xy, unsigned rad);
431
432
438constexpr double PI(unsigned n = 1, unsigned d = 1)
439{
440#ifdef false
441 return std::numbers::pi * n / d;
442#else
443 return 3.1415926535897932384626433832795 * n / d;
444#endif
445}
446
450/*dnd::Direction IndexRpg2Direction(size_t index)
451{
452 if (index == 0)
453 return Direction::DOWN;
454 if (index == 1)
455 return Direction::LEFT;
456 if (index == 2)
457 return Direction::RIGHT;
458 if (index == 3)
459 return Direction::UP;
460
461 debug_warn("错误的下标![0, 3]");
462 return Direction::DOWN;
463}*/
464
468//DirectionMask::Var Dir2Mask(const Vector2& dir)
469//{
470// if (Every::Zero(dir))
471// return DirectionMask::NONE;
472// double r = atan2(dir[1], dir[0]);//返回(-pi, pi],从正x轴向正y轴旋转
473// if (r < 0)//变换到(0, 2pi],x轴不变
474// r += (std::numbers::pi * 2.0);
475// r += (std::numbers::pi / 8.0);//四舍五入 加pi/8
476// size_t index = r / (std::numbers::pi / 4.0);//2pi分为8个方向为pi/4
477
478// dnd_assert(index >= 0 && index <= 7);
479// //x为0
480// if (index == 0)
481// return DirectionMask::RIGHT;
482// else if (index == 1)
483// return DirectionMask::RIGHT_DOWN;
484// else if (index == 2)
485// return DirectionMask::DOWN;
486// else if (index == 3)
487// return DirectionMask::LEFT_DOWN;
488// else if (index == 4)
489// return DirectionMask::LEFT;
490// else if (index == 5)
491// return DirectionMask::LEFT_UP;
492// else if (index == 6)
493// return DirectionMask::UP;
494// else if (index == 7)
495// return DirectionMask::RIGHT_UP;
496// return DirectionMask::NONE;
497//}
498
504template<IsReal T>
505constexpr T AlignF(T x, T align)
506{
507 assert(align > 0);
508
509 if (x < 0)
510 {
511 T ret = -align;
512 while (x < ret)
513 {
514 ret -= align;
515 }
516 return ret + align;
517 }
518 else
519 {
520 T ret = align;
521 while (x > ret)
522 {
523 ret += align;
524 }
525 return ret;
526 }
527}
528
533template<IsUnsigned T>
534constexpr T Align(T x, T align)
535{
536 assert(align != 0);
537
538 T ret = align;
539 while (x > ret)
540 {
541 ret += align;
542 }
543 return ret;
544}
545
549constexpr unsigned IsPow2(unsigned x)
550{
551 return x && !(x & (x - 1));
552}
553
558constexpr unsigned AlignPow2(unsigned x, unsigned align)
559{
560 if (!IsPow2(align))
561 return 0;
562
563 return (x + align - 1) & ~(align - 1);
564}
565
571constexpr unsigned div_found(unsigned n, unsigned d)
572{
573 unsigned q = n / d;
574 unsigned r = n % d;
575 return r >= (d >> 1) ? q + 1 : q;
576}
577
584constexpr unsigned div_found_fast(unsigned n, unsigned d)
585{
586 return (n + (d >> 1)) / d;
587}
588
600constexpr float OffsetOrder(float order, int u = 1, int v = 0, int w = 0)
601{
602 constexpr int NUM_ORDER_DT = 100;
603 float ret = order + (w + v * NUM_ORDER_DT + u * NUM_ORDER_DT * NUM_ORDER_DT)
604 * std::numeric_limits<float>::epsilon();
605 if (!is_saturate(ret))
606 {
607 log_("order超出范围:{}", ret);
608 return saturate(ret);
609 }
610 return ret;
611}
612
615constexpr Float CrossProduct(const Position2& a, const Position2& b)
616{
617 return a[0] * b[1] - a[1] * b[0];
618}
619
620constexpr Position3 CrossProduct(const Position3& a, const Position3& b)
621{
622 return {
623 a[1] * b[2] - b[1] * a[2],
624 a[2] * b[0] - b[2] * a[0],
625 a[0] * b[1] - b[0] * a[1]
626 };
627}
628
632template<typename T, size_t N>
633constexpr T DotProduct(const Array<T, N>& a, const Array<T, N>& b)
634{
635 T ret = 0;
636 for (size_t i = 0; i < N; ++i)
637 ret += a[i] * b[i];
638 return ret;
639}
640
645Position4 Slerp(const Position4& q0, const Position4& q1, const Float& t);
646
650//constexpr void Rect2Uv(const Size& tex_size, const RectU& rect, floatx2* uv)
651//{
652// floatx4 ltrb;
653// ltrb[LTRB::LEFT] = float(rect[LTRB::LEFT]) / tex_size[0];
654// ltrb[LTRB::TOP] = float(rect[LTRB::TOP]) / tex_size[1];
655// ltrb[LTRB::RIGHT] = float(rect[LTRB::RIGHT]) / tex_size[0];
656// ltrb[LTRB::BUTTOM] = float(rect[LTRB::BUTTOM]) / tex_size[1];
657//
658//
659// uv[Corner::LT] = { ltrb[LTRB::LEFT], ltrb[LTRB::TOP] };
660// uv[Corner::RT] = { ltrb[LTRB::RIGHT], ltrb[LTRB::TOP] };
661// uv[Corner::LB] = { ltrb[LTRB::LEFT], ltrb[LTRB::BUTTOM] };
662// uv[Corner::RB] = { ltrb[LTRB::RIGHT], ltrb[LTRB::BUTTOM] };
663//}
664
668template<typename C>
669constexpr auto DistanceDiagonal(const C& p0, const C& p1)
670{
671 C dt = p1 - p0;
672 Every::Abs(dt);
673 return Select::Max(dt);
674}
675
676
680std::vector<Point> DrawLineLerp(const Point& p0, const Point& p1);
681
685std::vector<Point> DrawLineBresenham(const Point& p0, const Point& p1);
686
691std::vector<Point> DrawLineOrth(const Point& p0, const Point& p1);
692
697std::vector<Point> DrawLineCover(const Point& p0, const Point& p1);
698
703void MergePath(std::list<Point>& list_pos);
704
709template<typename F>
710void MergePathDirect(std::list<Point>& list_pos, F func_pass)
711{
712 if (list_pos.size() < 3)
713 return;
714 auto iter_last = list_pos.end();//最后一个点总是有效的
715 --iter_last;
716 for (auto iter_0 = list_pos.begin(); iter_0 != iter_last;)
717 {//直到前一个点到 iter_last(最后一个点)
718 //iter_0的下一个点
719 auto iter_0_next = iter_0;
720 ++iter_0_next;
721 //是否删除了节点
722 bool b_del = false;
723 for (auto iter_1 = iter_last; iter_1 != iter_0_next; --iter_1)
724 {//后一个点 从后往前遍历,直到iter_0_next
725 if (func_pass(*iter_0, *iter_1))
726 {//如果可通行 删除中间的节点
727 for (auto iter = iter_0_next; iter != iter_1;)
728 iter = list_pos.erase(iter);
729 iter_0 = iter_1;//后一个点此时成为起点
730 b_del = true;
731 break;
732 }
733 }
734 if (!b_del)
735 ++iter_0;
736 }
737}
738
739
740//----------------Quad和Rect的操作不同,Quad需要加名字-------
744template<typename T>
745constexpr T GetQuadSize(const Array<T, 4>& quad)
746{
747 return quad[2] - quad[0];
748}
749
754template<typename T>
756{
757 return { quad[0], quad[1], quad[2] };
758}
759template<typename T>
761{
762 return { quad[0], quad[2], quad[3] };
763}
764
770template<typename T>
771constexpr bool IsRectValid(const Array<T, 4>& rect)
772{
773 return rect[0] <= rect[2]
774 && rect[1] <= rect[3];
775}
776
780template<typename T>
781constexpr bool IsRectEmpty(const Array<T, 4>& rect)
782{
783 return rect[0] == rect[2]
784 && rect[1] == rect[3];
785}
786
791template<typename T>
792constexpr bool IsRectInSize(const Array<T, 4>& rect, const Size& size)
793{
794 if (!IsRectValid(rect))
795 return false;
796 return rect[0] >= 0
797 && rect[1] >= 0
798 && rect[2] <= size[0]
799 && rect[3] <= size[1];
800}
801
805constexpr bool IsXyInSize(const Point& xy, const Size& size)
806{
807 if (Each::Less(xy, {}))
808 return false;
809 return unsigned(xy[0]) < size[0]
810 && unsigned(xy[1]) < size[1];
811}
812
817constexpr bool IsXyInRect(const Point& xy, const Rect& rect)
818{
819 return xy[0] >= rect[0]
820 && xy[1] >= rect[1]
821 && xy[0] < rect[2]
822 && xy[1] < rect[3];
823}
824
828constexpr bool IsTriangle(const Triangle& triangle)
829{
830 Position ab = triangle[0] - triangle[1];
831 Position ac = triangle[0] - triangle[2];
832
833 return CrossProduct(ab, ac) != 0;
834}
835
841constexpr bool IsDotInTriangle(const Position& dot, const Triangle& triangle)
842{
843 if (!IsTriangle(triangle))
844 return false;
845 Position pa = triangle[0] - dot;
846 Position pb = triangle[1] - dot;
847 Position pc = triangle[2] - dot;
848 Float t1 = CrossProduct(pa, pb);
849 Float t2 = CrossProduct(pb, pc);
850 Float t3 = CrossProduct(pc, pa);
851 return t1 * t2 >= 0 &&
852 t1 * t3 >= 0 &&
853 t2 * t3 >= 0;
854}
855
861constexpr bool IsDotInQuad(const Position& dot, const Quad& quad)
862{
863 return Math::IsDotInTriangle(dot, GetQuadTriangle0(quad))
865}
866
872//constexpr bool IsDotInQuadConvex(const Position& dot, const Quad& quad)
873//{
874//
875//}
876
881{
882 return { w, w * Numbers::RATIO_GOLD };
883}
884
885}
用于模板限定,更好的报错信息
日志系统
#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)
叉乘(四指指向a,弯向b,大拇指指向c)
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 画线算法
T Distance(const Array< T, 3 > &a)
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
void log(std::string_view str, DL_SOURCE_LOCATION)
以当前设置输出
Point2U PointU
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