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(std::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(std::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{
75template<typename T>
76[[deprecated]]
77constexpr T Limit(const T& v, const T& v_min, const T& v_max)
78{
79 if (v < v_min)
80 return v_min;
81 if (v_max < v)
82 return v_max;
83 return v;
84}
85
89template<typename T>
90constexpr bool IsOutRange(T x, T a, T b)
91{
92 return x < a || b < x;
93}
94
95
101template<typename T>
102constexpr T Pow(T x, T n)
103{
104 T ret = 1;
105 for (T i = 0; i < n; ++i)
106 {
107 ret *= x;
108 }
109 return ret;
110}
111constexpr uint64_t Pow64(uint64_t x, uint8_t n)
112{
113 uint64_t ret = 1;
114 for (uint8_t i = 0; i < n; ++i)
115 {
116 ret *= x;
117 }
118 return ret;
119}
120constexpr uint32_t Pow32(uint32_t x, uint8_t n)
121{
122 uint32_t ret = 1;
123 for (uint8_t i = 0; i < n; ++i)
124 {
125 ret *= x;
126 }
127 return ret;
128}
129
133constexpr uint64_t ARRAY_POW2[] = {
134 Pow64(2,0),Pow64(2,1),Pow64(2,2),Pow64(2,3),Pow64(2,4),Pow64(2,5),Pow64(2,6),Pow64(2,7),
135 Pow64(2,8),Pow64(2,9),Pow64(2,10),Pow64(2,11),Pow64(2,12),Pow64(2,13),Pow64(2,14),Pow64(2,15),
136 Pow64(2,16),Pow64(2,17),Pow64(2,18),Pow64(2,19),Pow64(2,20),Pow64(2,21),Pow64(2,22),Pow64(2,23),
137 Pow64(2,24),Pow64(2,25),Pow64(2,26),Pow64(2,27),Pow64(2,28),Pow64(2,29),Pow64(2,30),Pow64(2,31),
138 Pow64(2,32),Pow64(2,33),Pow64(2,34),Pow64(2,35),Pow64(2,36),Pow64(2,37),Pow64(2,38),Pow64(2,39),
139 Pow64(2,40),Pow64(2,41),Pow64(2,42),Pow64(2,43),Pow64(2,44),Pow64(2,45),Pow64(2,46),Pow64(2,47),
140 Pow64(2,48),Pow64(2,49),Pow64(2,50),Pow64(2,51),Pow64(2,52),Pow64(2,53),Pow64(2,54),Pow64(2,55),
141 Pow64(2,56),Pow64(2,57),Pow64(2,58),Pow64(2,59),Pow64(2,60),Pow64(2,61),Pow64(2,62),Pow64(2,63) };
142constexpr uint32_t ARRAY_POW2_32[] = {
143 Pow32(2,0),Pow32(2,1),Pow32(2,2),Pow32(2,3),Pow32(2,4),Pow32(2,5),Pow32(2,6),Pow32(2,7),
144 Pow32(2,8),Pow32(2,9),Pow32(2,10),Pow32(2,11),Pow32(2,12),Pow32(2,13),Pow32(2,14),Pow32(2,15),
145 Pow32(2,16),Pow32(2,17),Pow32(2,18),Pow32(2,19),Pow32(2,20),Pow32(2,21),Pow32(2,22),Pow32(2,23),
146 Pow32(2,24),Pow32(2,25),Pow32(2,26),Pow32(2,27),Pow32(2,28),Pow32(2,29),Pow32(2,30),Pow32(2,31) };
147
153#define DND_ARRAY_POW_LINE(index) if (x <= ARRAY_POW2[index])return ARRAY_POW2[index]
154constexpr uint64_t CeilToPow2(uint64_t&& x)
155{
164
165 log("数值过大,超过2^63:" + std::to_string(x));
166 return 0;
167}
168#define DND_ARRAY_POW_LINE_32(index) if (x <= ARRAY_POW2_32[index])return ARRAY_POW2_32[index]
179
184template <typename T>
185inline T CeilToPow2(const T& x)
186{
187#if (DL_PLATFORM == DL_PLATFORM_WIN32)
188 return std::bit_ceil(x);
189#else
190 return CeilToPow2(x);
191#endif
192}
193
194
201inline float RSqrt(float x)
202{
203 long i;
204 float x2, y;
205 const float threehalfs = 1.5f;
206
207 x2 = x * 0.5f;
208 y = x;
209 i = *(long*)&y;
210 i = 0x5f3759df - (i >> 1);
211 y = *(float*)&i;
212 y = y * (threehalfs - (x2 * y * y));
213 return y;
214}
215
216
220template<size_t N>
221void NormalizeFast(std::array<float, N>& v)
222{
223 float length = 0;
224 for (size_t i = 0; i < N; ++i)
225 {
226 length += (v[i] * v[i]);
227 }
228
229 length = RSqrt(length);
230 for (size_t i = 0; i < N; ++i)
231 {
232 v[i] *= length;
233 }
234}
235
236//-------------------------------有符号距离-----------------------------
241template <IsSigned T>
242T DistancePow2(const std::array<T, 2>& a)
243{
244 return a[0] * a[0] + a[1] * a[1];
245}
246
247template <IsSigned T>
248T DistancePow2(const std::array<T, 3>& a)
249{
250 return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
251}
252
253template <IsSigned T>
254T DistancePow2(const std::array<T, 4>& a)
255{
256 return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
257}
258
263template <IsSigned T>
264T DistancePow2(const std::array<T, 2>& a, const std::array<T, 2>& b)
265{
266 return DistancePow2(b - a);
267}
268
269
270//---------------------------------无符号距离----------------------------------------
274template <IsUnsigned T>
275T DisU(T a, T b)
276{
277 return a > b ? a - b : b - a;
278}
279
283template <IsUnsigned T0, IsSigned T1>
284[[nodiscard]]
285T0 AddU(T0 a, T1 b)
286{
287 if (b < 0 && (T0)(-b) > a)
288 return 0;
289 else
290 return a + b;
291}
292
293
298template <IsUnsigned T>
299T DistancePow2U(const std::array<T, 2>& a, const std::array<T, 2>& b)
300{
301 unsigned dx = DisU(a[0], b[0]);
302 unsigned dy = DisU(a[1], b[1]);
303 return dx * dx + dy * dy;
304}
305
309template <IsSigned T, size_t N>
310void Normalize(std::array<T, N>& v)
311{
312 T length = DistancePow2(v);
313 length = sqrt(length);
314
315 v /= length;
316}
317
318template <IsSigned T, size_t N>
319[[nodiscard]]
320std::array<T, N> Normalize(const std::array<T, N>& v)
321{
322 std::array<T, N> ret = v;
323 Normalize(ret);
324 return ret;
325}
326
332std::vector<PointU> getCircle(const Size& size, const PointU& xy, unsigned rad);
333
338std::vector<Point> getCircle(const Point& xy, unsigned rad);
339
340
346constexpr double PI(unsigned n = 1, unsigned d = 1)
347{
348#ifdef __cpp_lib_concepts
349 return std::numbers::pi * n / d;
350#else
351 return 3.1415926535897932384626433832795 * n / d;
352#endif
353}
354
358/*dnd::Direction IndexRpg2Direction(size_t index)
359{
360 if (index == 0)
361 return Direction::DOWN;
362 if (index == 1)
363 return Direction::LEFT;
364 if (index == 2)
365 return Direction::RIGHT;
366 if (index == 3)
367 return Direction::UP;
368
369 debug_warn("错误的下标![0, 3]");
370 return Direction::DOWN;
371}*/
372
376//DirectionMask::Var Dir2Mask(const Vector2& dir)
377//{
378// if (Every::Zero(dir))
379// return DirectionMask::NONE;
380// double r = atan2(dir[1], dir[0]);//返回(-pi, pi],从正x轴向正y轴旋转
381// if (r < 0)//变换到(0, 2pi],x轴不变
382// r += (std::numbers::pi * 2.0);
383// r += (std::numbers::pi / 8.0);//四舍五入 加pi/8
384// size_t index = r / (std::numbers::pi / 4.0);//2pi分为8个方向为pi/4
385
386// dnd_assert(index >= 0 && index <= 7);
387// //x为0
388// if (index == 0)
389// return DirectionMask::RIGHT;
390// else if (index == 1)
391// return DirectionMask::RIGHT_DOWN;
392// else if (index == 2)
393// return DirectionMask::DOWN;
394// else if (index == 3)
395// return DirectionMask::LEFT_DOWN;
396// else if (index == 4)
397// return DirectionMask::LEFT;
398// else if (index == 5)
399// return DirectionMask::LEFT_UP;
400// else if (index == 6)
401// return DirectionMask::UP;
402// else if (index == 7)
403// return DirectionMask::RIGHT_UP;
404// return DirectionMask::NONE;
405//}
406
412template<IsReal T>
413constexpr T AlignF(T x, T align)
414{
415 dnd_assert(align > 0);
416
417 if (x < 0)
418 {
419 T ret = -align;
420 while (x < ret)
421 {
422 ret -= align;
423 }
424 return ret + align;
425 }
426 else
427 {
428 T ret = align;
429 while (x > ret)
430 {
431 ret += align;
432 }
433 return ret;
434 }
435}
436
441template<IsUnsigned T>
442constexpr T Align(T x, T align)
443{
444 assert(align != 0);
445
446 T ret = align;
447 while (x > ret)
448 {
449 ret += align;
450 }
451 return ret;
452}
453
458constexpr unsigned AlignPow2(unsigned x, unsigned align)
459{
460 if ((0 == align) || (align & (align - 1)))
461 {
462 return 0;
463 }
464
465 return ((x + (align - 1)) & ~(align - 1));
466}
467
473constexpr unsigned div_found(unsigned n, unsigned d)
474{
475 unsigned q = n / d;
476 unsigned r = n % d;
477 return r >= (d >> 1) ? q + 1 : q;
478}
479
486constexpr unsigned div_found_fast(unsigned n, unsigned d)
487{
488 return (n + (d >> 1)) / d;
489}
490
502constexpr float OffsetOrder(float order, int u = 1, int v = 0, int w = 0)
503{
504 constexpr int NUM_ORDER_DT = 32;
505 float ret = order + (w + v * NUM_ORDER_DT + u * NUM_ORDER_DT * NUM_ORDER_DT)
506 * std::numeric_limits<float>::epsilon();
507 if (!is_saturate(ret))
508 {
509 log_("order超出范围:{}", ret);
510 return saturate(ret);
511 }
512 return ret;
513}
514
517constexpr Float CrossProduct(const Position2& a, const Position2& b)
518{
519 return a[0] * b[1] - a[1] * b[0];
520}
521
522constexpr Position3 CrossProduct(const Position3& a, const Position3& b)
523{
524 return {
525 a[1] * b[2] - b[1] * a[2],
526 a[2] * b[0] - b[2] * a[0],
527 a[0] * b[1] - b[0] * a[1]
528 };
529}
530
534template<typename T, size_t N>
535constexpr T DotProduct(const std::array<T, N>& a, const std::array<T, N>& b)
536{
537 T ret = 0;
538 for (size_t i = 0; i < N; ++i)
539 ret += a[i] * b[i];
540 return ret;
541}
542
547Position4 Slerp(const Position4& q0, const Position4& q1, const Float& t);
548
552//constexpr void Rect2Uv(const Size& tex_size, const RectU& rect, floatx2* uv)
553//{
554// floatx4 ltrb;
555// ltrb[LTRB::LEFT] = float(rect[LTRB::LEFT]) / tex_size[0];
556// ltrb[LTRB::TOP] = float(rect[LTRB::TOP]) / tex_size[1];
557// ltrb[LTRB::RIGHT] = float(rect[LTRB::RIGHT]) / tex_size[0];
558// ltrb[LTRB::BUTTOM] = float(rect[LTRB::BUTTOM]) / tex_size[1];
559//
560//
561// uv[Corner::LT] = { ltrb[LTRB::LEFT], ltrb[LTRB::TOP] };
562// uv[Corner::RT] = { ltrb[LTRB::RIGHT], ltrb[LTRB::TOP] };
563// uv[Corner::LB] = { ltrb[LTRB::LEFT], ltrb[LTRB::BUTTOM] };
564// uv[Corner::RB] = { ltrb[LTRB::RIGHT], ltrb[LTRB::BUTTOM] };
565//}
566
570template<typename C>
571constexpr auto DistanceDiagonal(const C& p0, const C& p1)
572{
573 C dt = p1 - p0;
574 Every::Abs(dt);
575 return Select::Max(dt);
576}
577
578
582std::vector<Point> DrawLineLerp(const Point& p0, const Point& p1);
583
587std::vector<Point> DrawLineBresenham(const Point& p0, const Point& p1);
588
593std::vector<Point> DrawLineOrth(const Point& p0, const Point& p1);
594
599std::vector<Point> DrawLineCover(const Point& p0, const Point& p1);
600
605void MergePath(std::list<Point>& list_pos);
606
611template<typename F>
612void MergePathDirect(std::list<Point>& list_pos, F func_pass)
613{
614 if (list_pos.size() < 3)
615 return;
616 auto iter_last = list_pos.end();//最后一个点总是有效的
617 --iter_last;
618 for (auto iter_0 = list_pos.begin(); iter_0 != iter_last;)
619 {//直到前一个点到 iter_last(最后一个点)
620 //iter_0的下一个点
621 auto iter_0_next = iter_0;
622 ++iter_0_next;
623 //是否删除了节点
624 bool b_del = false;
625 for (auto iter_1 = iter_last; iter_1 != iter_0_next; --iter_1)
626 {//后一个点 从后往前遍历,直到iter_0_next
627 if (func_pass(*iter_0, *iter_1))
628 {//如果可通行 删除中间的节点
629 for (auto iter = iter_0_next; iter != iter_1;)
630 iter = list_pos.erase(iter);
631 iter_0 = iter_1;//后一个点此时成为起点
632 b_del = true;
633 break;
634 }
635 }
636 if (!b_del)
637 ++iter_0;
638 }
639}
640
646template<typename T>
647constexpr bool IsValidRect(const std::array<T, 4>& rect)
648{
649 return rect[0] <= rect[2]
650 && rect[1] <= rect[3];
651}
652
657template<typename T>
658constexpr bool IsRectInSize(const std::array<T, 4>& rect, const Size& size)
659{
660 if (!IsValidRect(rect))
661 return false;
662 return rect[0] >= 0
663 && rect[1] >= 0
664 && rect[2] <= size[0]
665 && rect[3] <= size[1];
666}
667
671constexpr bool IsXyInSize(const Point& xy, const Size& size)
672{
673 if (Each::Less(xy, {}))
674 return false;
675 return unsigned(xy[0]) < size[0]
676 && unsigned(xy[1]) < size[1];
677}
678
683constexpr bool IsXyInRect(const Point& xy, const Rect& rect)
684{
685 return xy[0] >= rect[0]
686 && xy[1] >= rect[1]
687 && xy[0] < rect[2]
688 && xy[1] < rect[3];
689}
690
696constexpr bool IsDotInTriangle(const Position& dot, const Triangle& triangle)
697{
698 Position pa = triangle[0] - dot;
699 Position pb = triangle[1] - dot;
700 Position pc = triangle[2] - dot;
701 double t1 = CrossProduct(pa, pb);
702 double t2 = CrossProduct(pb, pc);
703 double t3 = CrossProduct(pc, pa);
704 return t1 * t2 >= 0 &&
705 t1 * t3 >= 0 &&
706 t2 * t3 >= 0;
707}
708
714constexpr bool IsDotInQuad(const Position& dot, const Quad& quad)
715{
716 return Math::IsDotInTriangle(dot, { quad[0], quad[1], quad[2] })
717 || Math::IsDotInTriangle(dot, { quad[0], quad[2], quad[3] });
718}
719
724{
725 return { w, w * Numbers::RATIO_GOLD };
726}
727
728}
用于模板限定,更好的报错信息
日志系统
#define log_(...)
#define DND_ARRAY_POW_LINE_32(index)
#define DND_ARRAY_POW_LINE(index)
向上取2的幂次
平台宏
范围操作
通用类型
constexpr bool Less(const std::array< T, N > &a, const std::array< T, N > &b)
每个元素都小于返回真
void Abs(C &c)
取绝对值
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)
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)
叉乘
void Normalize(std::array< T, N > &v)
向量单位化
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资源下标转方向
constexpr unsigned div_found(unsigned n, unsigned d)
无符号除法,返回四舍五入结果
constexpr bool IsXyInSize(const Point &xy, const Size &size)
判断 点是否在大小内
constexpr uint32_t Pow32(uint32_t x, uint8_t n)
constexpr T Pow(T x, T n)
返回x的n次方
std::vector< Point > DrawLineCover(const Point &p0, const Point &p1)
覆盖 画线算法
constexpr unsigned div_found_fast(unsigned n, unsigned d)
无符号除法,返回四舍五入结果
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)
路径合并(网格路径)
constexpr T DotProduct(const std::array< T, N > &a, const std::array< T, N > &b)
点乘
float RSqrt(float x)
返回平方根的倒数
constexpr bool IsRectInSize(const std::array< T, 4 > &rect, const Size &size)
判断 矩形 在 大小 内,首先它必须是有效的矩形
T DisU(T a, T b)
返回无符号类型的差值
T DistancePow2(const std::array< T, 2 > &a)
返回 向量 距离的平方
constexpr uint64_t ARRAY_POW2[]
2的整数次幂列表
std::vector< Point > DrawLineBresenham(const Point &p0, const Point &p1)
bresenham 画线算法
constexpr auto DistanceDiagonal(const C &p0, const C &p1)
纹理区域转uv
std::vector< PointU > getCircle(const Size &size, const PointU &xy, unsigned rad)
返回圆形范围的节点,考虑越界
constexpr bool IsValidRect(const std::array< T, 4 > &rect)
判断 矩形 是否有效
constexpr bool IsDotInQuad(const Position &dot, const Quad &quad)
判断点是否在凸四边形内
constexpr T Limit(const T &v, const T &v_min, const T &v_max)
限制数值到 闭区间
constexpr uint64_t CeilToPow2(uint64_t &&x)
T0 AddU(T0 a, T1 b)
无符号 加 有符号,防止小于0
constexpr bool IsDotInTriangle(const Position &dot, const Triangle &triangle)
判断点是否在三角形内
T DistancePow2U(const std::array< T, 2 > &a, const std::array< T, 2 > &b)
返回 距离的平方
void NormalizeFast(std::array< float, N > &v)
向量单位化,精度低速度快
类似std::numbers的常数
constexpr Float EULER
自然常数
constexpr Float EARTH_fADIUS
地球半径km
constexpr Float GRAVITY
地球重力加速度(赤道最小)
constexpr Float RATIO_GOLD
黄金比例
类似numeric头文件的数值操作
void Max(std::array< T, N > &container)
void Min(std::array< T, N > &container)
返回的是最小正数(假设有符号)
constexpr auto Max(const C &container)
返回容器最大值
Position2 Position
std::array< Float, 3 > Position3
std::array< Float, 4 > Position4
float Float
std::array< Position, 4 > Quad
constexpr T is_saturate(const T &x)
是否数值在[0, 1]
Point2U PointU
void log(std::string_view str, const std::source_location location=std::source_location::current())
以当前设置输出
std::array< Position, 3 > Triangle
constexpr T saturate(const T &x)
限制数值到 [0, 1]
Point4 Rect
PointU Size
Point2 Point
std::array< Float, 2 > Position2