Nebula
Loading...
Searching...
No Matches
scalar.h
Go to the documentation of this file.
1#pragma once
2//------------------------------------------------------------------------------
17
18
19
20namespace Math
21{
22#ifndef PI
23#define PI (3.1415926535897932384626433832795028841971693993751)
24#endif
25
26// the half circle
27#ifndef N_PI
28#define N_PI (Math::scalar(PI))
29#endif
30// the whole circle
31#ifndef N_PI_DOUBLE
32#define N_PI_DOUBLE (Math::scalar(6.283185307179586476925286766559))
33#endif
34// a quarter circle
35#ifndef N_PI_HALF
36#define N_PI_HALF (Math::scalar(1.5707963267948966192313216916398f))
37#endif
38// ---HOTFIXED
39
40#ifndef TINY
41#define TINY (0.0000001f)
42#endif
43#define N_TINY TINY
44
45typedef float scalar;
46typedef float float32;
47typedef double float64;
48
49#ifndef PI
50#define PI (3.1415926535897932384626433832795028841971693993751)
51#endif
52// the half circle
53#ifndef N_PI
54#define N_PI (Math::scalar(3.1415926535897932384626433832795028841971693993751))
55#endif
56
57struct float2
58{
59 union
60 {
61 struct { scalar x, y; };
63 };
64};
65
66struct float3
67{
68 union
69 {
70 struct { scalar x, y, z; };
72 };
73};
74
75struct float4
76{
77 union
78 {
79 struct { scalar x, y, z, w; };
81 };
82};
83
84struct int2
85{
86 union
87 {
88 struct { int x, y; };
89 int v[2];
90 };
91};
92
93struct int3
94{
95 union
96 {
97 struct { int x, y, z; };
98 int v[3];
99 };
100};
101
102struct int4
103{
104 union
105 {
106 struct { int x, y, z, w; };
107 int v[4];
108 };
109};
110
111struct uint2
112{
113 union
114 {
115 struct { unsigned int x, y; };
116 unsigned int v[2];
117 };
118};
119
120struct uint3
121{
122 union
123 {
124 struct { unsigned int x, y, z; };
125 unsigned int v[3];
126 };
127};
128
129struct uint4
130{
131 union
132 {
133 struct { unsigned int x, y, z, w; };
134 unsigned int v[4];
135 };
136};
137
138struct byte4u
139{
140 union
141 {
142 struct { ubyte x, y, z, w; };
143 unsigned int v;
144 };
145};
146
147struct byte4
148{
149 union
150 {
151 struct { byte x, y, z, w; };
152 unsigned int v;
153 };
154};
155
156//------------------------------------------------------------------------------
160__forceinline scalar
162{
163 return scalar(::rand()) / scalar(RAND_MAX);
164}
165
166//------------------------------------------------------------------------------
170__forceinline scalar
172{
173 scalar unit = scalar(::rand()) / RAND_MAX;
174 scalar diff = max - min;
175 return min + unit * diff;
176}
177
178//------------------------------------------------------------------------------
181__forceinline scalar
183{
184 return sinf(x);
185}
186
187//------------------------------------------------------------------------------
190__forceinline scalar
192{
193 return cosf(x);
194}
195
196//------------------------------------------------------------------------------
199__forceinline scalar
201{
202 return tanf(x);
203}
204
205//------------------------------------------------------------------------------
208__forceinline scalar
210{
211 return asinf(x);
212}
213
214//------------------------------------------------------------------------------
217__forceinline scalar
219{
220 return acosf(x);
221}
222
223//------------------------------------------------------------------------------
226__forceinline scalar
228{
229 return atanf(x);
230}
231
232//------------------------------------------------------------------------------
235__forceinline scalar
237{
238 return sqrtf(x);
239}
240
241//------------------------------------------------------------------------------
245__forceinline int
247{
249 return int(f);
250}
251
252//------------------------------------------------------------------------------
255__forceinline scalar
257{
258 return fmodf(x, y);
259}
260
261//------------------------------------------------------------------------------
264__forceinline scalar
266{
267 return x - (int)x;
268}
269
270//------------------------------------------------------------------------------
276__forceinline scalar
278{
279#if 0
280 static const scalar rev = scalar(6.283185307179586476925286766559);
281 return n_fmod(a,rev);
282#else
283 static const scalar REVOLUTION = scalar(6.283185307179586476925286766559);
284 a += N_PI;
285 scalar temp = fabsf(a);
286 temp = temp - floorf(temp/REVOLUTION) * REVOLUTION;
287 temp -= N_PI;
288 temp = a<0 ? -temp:temp;
289 if(temp < scalar(-N_PI)) temp += REVOLUTION;
290 if(temp >= scalar(N_PI)) temp -= REVOLUTION;
291 return temp;
292#endif
293}
294
295//------------------------------------------------------------------------------
299__forceinline scalar
301{
302 return log2f(f);
303}
304
305//------------------------------------------------------------------------------
308__forceinline scalar
310{
311 return exp2f(x);
312}
313
314//------------------------------------------------------------------------------
318__forceinline scalar
320{
321 return logf(x);
322}
323
324//------------------------------------------------------------------------------
327__forceinline scalar
329{
330 return expf(x);
331}
332
333//------------------------------------------------------------------------------
337__forceinline int
339{
340 return fchop(floorf(f + 0.5f));
341}
342
343//------------------------------------------------------------------------------
346__forceinline scalar
348{
349 return powf(x, y);
350}
351
352//------------------------------------------------------------------------------
356__forceinline bool
358{
359 scalar f = f0 - f1;
360 return ((f > (-tol)) && (f < tol));
361}
362
363//------------------------------------------------------------------------------
366template<typename TYPE>
367__forceinline TYPE
368max(TYPE a, TYPE b)
369{
370 return (a > b) ? a : b;
371}
372
373//------------------------------------------------------------------------------
376template<typename TYPE0, typename ...TYPEN>
377__forceinline TYPE0
378max(TYPE0 first, TYPE0 second, TYPEN... rest)
379{
380 return first > second ? max(first, std::forward<TYPEN>(rest)...) : max(second, std::forward<TYPEN>(rest)...);
381}
382
383//------------------------------------------------------------------------------
387template<>
388__forceinline unsigned int
389max(unsigned int a, unsigned int b)
390{
391 return a ^ ((a ^ b) & -(a < b));
392}
393
394//------------------------------------------------------------------------------
397template<typename TYPE>
398__forceinline TYPE
399min(TYPE a, TYPE b)
400{
401 return (a < b) ? a : b;
402}
403
404//------------------------------------------------------------------------------
408template<>
409__forceinline unsigned int
410min(unsigned int a, unsigned int b)
411{
412 return b ^ ((a ^ b) & -(a < b));
413}
414
415//------------------------------------------------------------------------------
419template<>
420__forceinline uint16_t
421min(uint16_t a, uint16_t b)
422{
423 return b ^ ((a ^ b) & -(a < b));
424}
425
426//------------------------------------------------------------------------------
429template<typename TYPE0, typename ...TYPEN>
430__forceinline TYPE0
431min(TYPE0 first, TYPE0 second, TYPEN... rest)
432{
433 return first < second ? min(first, std::forward<TYPEN>(rest)...) : min(second, std::forward<TYPEN>(rest)...);
434}
435
436//------------------------------------------------------------------------------
439
440__forceinline scalar
442{
443 return (a < 0.0f) ? -a : a;
444}
445
446//------------------------------------------------------------------------------
449__forceinline double
450abs(double a)
451{
452 return (a < 0.0) ? -a : a;
453}
454
455//------------------------------------------------------------------------------
458__forceinline int
459abs(int a)
460{
461 return (a < 0) ? -a : a;
462}
463
464//------------------------------------------------------------------------------
467__forceinline scalar
469{
470 return (a < 0.0f) ? -1.0f : 1.0f;
471}
472
473//------------------------------------------------------------------------------
476__forceinline constexpr scalar
478{
479 return (scalar)((d * N_PI) / 180.0f);
480}
481
482//------------------------------------------------------------------------------
485__forceinline constexpr scalar
487{
488 return (scalar)((r * 180.0f) / N_PI);
489}
490
491//------------------------------------------------------------------------------
495__forceinline float
496clamp(float val, float minVal, float maxVal)
497{
498 if (val < minVal) return minVal;
499 else if (val > maxVal) return maxVal;
500 else return val;
501}
502
503//------------------------------------------------------------------------------
507__forceinline int64_t
508clamp(int64_t val, int64_t minVal, int64_t maxVal)
509{
510 if (val < minVal) return minVal;
511 else if (val > maxVal) return maxVal;
512 else return val;
513}
514
515//------------------------------------------------------------------------------
519__forceinline int32_t
520clamp(int32_t val, int32_t minVal, int32_t maxVal)
521{
522 if (val < minVal) return minVal;
523 else if (val > maxVal) return maxVal;
524 else return val;
525}
526
527//------------------------------------------------------------------------------
531__forceinline float
532ceil(float val)
533{
534 return ceilf(val);
535}
536
537//------------------------------------------------------------------------------
541__forceinline float
542floor(float val)
543{
544 return floorf(val);
545}
546
547//------------------------------------------------------------------------------
551__forceinline float
552round(float val)
553{
554 return roundf(val);
555}
556
557//------------------------------------------------------------------------------
561__forceinline bool
563{
564 return ((f0 - f1) < tol);
565}
566
567//------------------------------------------------------------------------------
571__forceinline bool
573{
574 return ((f0 - f1) > tol);
575}
576
577//------------------------------------------------------------------------------
581__forceinline scalar
583{
584 if (val < 0.0f) return 0.0f;
585 else if (val > 1.0f) return 1.0f;
586 else return val;
587}
588
589//------------------------------------------------------------------------------
593__forceinline double
594saturate(double val)
595{
596 if (val < 0.0) return 0.0;
597 else if (val > 1.0) return 1.0;
598 else return val;
599}
600
601//------------------------------------------------------------------------------
605__forceinline float
606lerp(float x, float y, float l)
607{
608 return x + l * (y - x);
609}
610
611//------------------------------------------------------------------------------
615__forceinline scalar
617{
618 scalar normFrom = modangle(from);
619 scalar normTo = modangle(to);
620 scalar dist = normTo - normFrom;
621 if (dist < deg2rad(-180.0f))
622 {
623 dist += deg2rad(360.0f);
624 }
625 else if (dist > deg2rad(180.0f))
626 {
627 dist -= deg2rad(360.0f);
628 }
629 return dist;
630}
631
632//------------------------------------------------------------------------------
636__forceinline bool
638{
639#if __GNUC__
640 union { scalar s; unsigned int u; } pun;
641 pun.s = s;
642 return ((pun.u&0x7f800000)==0);
643#else
644 return (((*(unsigned int*)&s)&0x7f800000)==0);
645#endif
646}
647
648//------------------------------------------------------------------------------
652__forceinline float
654{
655 if (isdenormal(s))
656 {
657 return 0.0f;
658 }
659 else
660 {
661 return s;
662 }
663}
664
665//------------------------------------------------------------------------------
669__forceinline bool
671{
672 return abs(a - b) <= epsilon;
673}
674
675//------------------------------------------------------------------------------
678__forceinline scalar
680{
681 return scalar(1.0) / tan(x);
682}
683
684//------------------------------------------------------------------------------
687__forceinline scalar
689{
690 // Scale, bias and saturate x to 0..1 range
691 x = saturate((x - edge0) / (edge1 - edge0));
692 // Evaluate polynomial
693 return x*x*(3-2*x);
694}
695
696//------------------------------------------------------------------------------
700__forceinline int
701irand(int min, int max)
702{
703 int range = max - min + 1;
704 int unit = ::rand() % range;
705 return min + unit;
706}
707
708//------------------------------------------------------------------------------
712__forceinline int
713mostsignificant(unsigned int val)
714{
715#ifdef WIN32
716 unsigned long ret;
717 bool res = _BitScanReverse(&ret, val);
718 ret = res ? ret : 0;
719 return ret + 1;
720#else
721 unsigned long ret;
722 ret = __builtin_clz(val);
723 return ret + 1;
724#endif
725}
726
727//------------------------------------------------------------------------------
730__forceinline unsigned int
731align(unsigned int alignant, unsigned int alignment)
732{
733 return (alignant + alignment - 1) & ~(alignment - 1);
734}
735
736//------------------------------------------------------------------------------
739__forceinline uintptr_t
740alignptr(uintptr_t alignant, uintptr_t alignment)
741{
742 return (alignant + alignment - 1) & ~(alignment - 1);
743}
744
745//------------------------------------------------------------------------------
748__forceinline unsigned int
749align_down(unsigned int alignant, unsigned int alignment)
750{
751 return (alignant / alignment * alignment);
752}
753
754//------------------------------------------------------------------------------
757__forceinline uintptr_t
758align_downptr(uintptr_t alignant, uintptr_t alignment)
759{
760 return (alignant / alignment * alignment);
761}
762
763//------------------------------------------------------------------------------
767__forceinline unsigned int
768divandroundup(unsigned int dividend, unsigned int divider)
769{
770 return (dividend % divider != 0) ? (dividend / divider + 1) : (dividend / divider);
771}
772
773//------------------------------------------------------------------------------
777__forceinline unsigned int
778roundtopow2(unsigned int val)
779{
780 val--;
781 val |= val >> 1;
782 val |= val >> 2;
783 val |= val >> 4;
784 val |= val >> 8;
785 val |= val >> 16;
786 val++;
787 return val;
788}
789
790//------------------------------------------------------------------------------
795{
797};
798
799__forceinline uint64
801{
802 uint64_t t = state.x[0];
803 uint64_t const s = state.x[1];
804 state.x[0] = s;
805 t ^= t << 23; // a
806 t ^= t >> 18; // b -- Again, the shifts and the multipliers are tunable
807 t ^= s ^ (s >> 5); // c
808 state.x[1] = t;
809 return t + s;
810}
811
812//------------------------------------------------------------------------------
816__forceinline uint32_t
817pointerhash(void* ptr)
818{
819 return (uint32_t) (((uintptr_t)(void *)ptr) % 4294967291u);
820}
821
822
823//------------------------------------------------------------------------------
827inline float
828normtofloat(uint16_t value)
829{
830 return (float)value / 65535.0f;
831}
832
833//------------------------------------------------------------------------------
837inline float
838normtofloat(int16_t value)
839{
840 return Math::max((float)value / 32767.0f, -1.0f);
841}
842
843//------------------------------------------------------------------------------
847inline float
848normtofloat(uint8_t value)
849{
850 return (float)value / 255.0f;
851}
852
853//------------------------------------------------------------------------------
857inline float
858normtofloat(int8_t value)
859{
860 return Math::max((float)value / 127.0f, -1.0f);
861}
862
863} // namespace Math
864
865//------------------------------------------------------------------------------
869inline long double
870operator"" _rad(long double deg)
871{
872 return Math::deg2rad(deg);
873}
874
875//------------------------------------------------------------------------------
878inline long double
879operator"" _rad(unsigned long long deg)
880{
881 return Math::deg2rad(deg);
882}
883
884//------------------------------------------------------------------------------
888inline long double
889operator"" _deg(long double rad)
890{
891 return Math::rad2deg(rad);
892}
893
894//------------------------------------------------------------------------------
897inline long double
898operator"" _deg(unsigned long long deg)
899{
900 return Math::rad2deg(deg);
901}
902
903//------------------------------------------------------------------------------
Different curves.
Definition angularpfeedbackloop.h:17
__forceinline uintptr_t alignptr(uintptr_t alignant, uintptr_t alignment)
Definition scalar.h:740
__forceinline float undenormalize(scalar s)
Returns 0 if scalar is denormal.
Definition scalar.h:653
__forceinline constexpr scalar rad2deg(scalar r)
Definition scalar.h:486
__forceinline int mostsignificant(unsigned int val)
Returns the position of the most significant bit of the number.
Definition scalar.h:713
__forceinline bool fequal(scalar f0, scalar f1, scalar tol)
A fuzzy floating point equality check.
Definition scalar.h:357
__forceinline scalar cot(scalar x)
Definition scalar.h:679
__forceinline scalar sqrt(scalar x)
Definition scalar.h:236
__forceinline uint64 randxor(randxorstate &state)
Definition scalar.h:800
__forceinline scalar log(scalar x)
get logarithm of x
Definition scalar.h:319
__forceinline unsigned int align_down(unsigned int alignant, unsigned int alignment)
Definition scalar.h:749
__forceinline constexpr scalar deg2rad(scalar d)
Definition scalar.h:477
__forceinline scalar asin(scalar x)
Definition scalar.h:209
__forceinline scalar saturate(scalar val)
Saturate a value (clamps between 0.0f and 1.0f)
Definition scalar.h:582
__forceinline uint32_t pointerhash(void *ptr)
cheap pointer hash using modulo with a mersenne prime
Definition scalar.h:817
__forceinline scalar log2(scalar f)
log2() function.
Definition scalar.h:300
__forceinline int fchop(scalar f)
Chop float to int.
Definition scalar.h:246
float normtofloat(uint16_t value)
convert normalized uint16_t to float
Definition scalar.h:828
__forceinline int frnd(scalar f)
Round float to integer.
Definition scalar.h:338
__forceinline float round(float val)
Floating point rounding.
Definition scalar.h:552
__forceinline float ceil(float val)
Floating point ceiling.
Definition scalar.h:532
__forceinline float lerp(float x, float y, float l)
Linearly interpolate between 2 values: ret = x + l * (y - x)
Definition scalar.h:606
__forceinline scalar modangle(scalar a)
Normalize an angular value into the range rad(0) to rad(360).
Definition scalar.h:277
__forceinline int irand(int min, int max)
Return a pseudo integer random number between min and max.
Definition scalar.h:701
__forceinline scalar pow(scalar x, scalar y)
Definition scalar.h:347
__forceinline float clamp(float val, float minVal, float maxVal)
Float clamping.
Definition scalar.h:496
__forceinline unsigned int align(unsigned int alignant, unsigned int alignment)
Definition scalar.h:731
__forceinline scalar rand()
Return a pseudo random number between 0 and 1.
Definition scalar.h:161
__forceinline TYPE min(TYPE a, TYPE b)
Definition scalar.h:399
__forceinline scalar fract(scalar x)
Definition scalar.h:265
__forceinline bool isdenormal(scalar s)
Returns true if the input scalar is denormalized (#DEN)
Definition scalar.h:637
double float64
Definition scalar.h:47
__forceinline scalar smoothstep(scalar edge0, scalar edge1, scalar x)
Definition scalar.h:688
__forceinline scalar angulardistance(scalar from, scalar to)
Get angular distance.
Definition scalar.h:616
float scalar
Definition scalar.h:45
__forceinline uintptr_t align_downptr(uintptr_t alignant, uintptr_t alignment)
Definition scalar.h:758
__forceinline scalar exp(scalar x)
Definition scalar.h:328
__forceinline scalar exp2(scalar x)
Definition scalar.h:309
__forceinline TYPE max(TYPE a, TYPE b)
Definition scalar.h:368
__forceinline scalar sgn(scalar a)
Definition scalar.h:468
__forceinline scalar abs(scalar a)
Definition scalar.h:441
__forceinline scalar cos(scalar x)
Definition scalar.h:191
__forceinline unsigned int divandroundup(unsigned int dividend, unsigned int divider)
Integer division with rounding.
Definition scalar.h:768
__forceinline scalar acos(scalar x)
Definition scalar.h:218
__forceinline bool nearequal(const point &v0, const point &v1, float epsilon)
Definition point.h:485
__forceinline scalar sin(scalar x)
Definition scalar.h:182
__forceinline bool fless(scalar f0, scalar f1, scalar tol)
A fuzzy floating point less-then check.
Definition scalar.h:562
__forceinline bool fgreater(scalar f0, scalar f1, scalar tol)
A fuzzy floating point greater-then check.
Definition scalar.h:572
__forceinline unsigned int roundtopow2(unsigned int val)
Rounds up to next power of 2.
Definition scalar.h:778
__forceinline scalar atan(scalar x)
Definition scalar.h:227
__forceinline float floor(float val)
Floating point flooring.
Definition scalar.h:542
__forceinline scalar tan(scalar x)
Definition scalar.h:200
float float32
Definition scalar.h:46
__forceinline scalar fmod(scalar x, scalar y)
Definition scalar.h:256
#define N_PI
Definition scalar.h:28
Definition scalar.h:148
byte y
Definition scalar.h:151
byte w
Definition scalar.h:151
byte z
Definition scalar.h:151
unsigned int v
Definition scalar.h:152
byte x
Definition scalar.h:151
Definition scalar.h:139
ubyte x
Definition scalar.h:142
unsigned int v
Definition scalar.h:143
ubyte z
Definition scalar.h:142
ubyte w
Definition scalar.h:142
ubyte y
Definition scalar.h:142
Definition scalar.h:58
scalar x
Definition scalar.h:61
scalar v[2]
Definition scalar.h:62
scalar y
Definition scalar.h:61
Definition scalar.h:67
scalar x
Definition scalar.h:70
scalar y
Definition scalar.h:70
scalar v[3]
Definition scalar.h:71
scalar z
Definition scalar.h:70
Definition scalar.h:76
scalar x
Definition scalar.h:79
scalar v[4]
Definition scalar.h:80
scalar y
Definition scalar.h:79
scalar w
Definition scalar.h:79
scalar z
Definition scalar.h:79
Definition scalar.h:85
int v[2]
Definition scalar.h:89
int y
Definition scalar.h:88
int x
Definition scalar.h:88
Definition scalar.h:94
int x
Definition scalar.h:97
int z
Definition scalar.h:97
int v[3]
Definition scalar.h:98
int y
Definition scalar.h:97
Definition scalar.h:103
int z
Definition scalar.h:106
int w
Definition scalar.h:106
int x
Definition scalar.h:106
int y
Definition scalar.h:106
int v[4]
Definition scalar.h:107
fast random generator based on xorshift+
Definition scalar.h:795
uint64 x[2]
Definition scalar.h:796
Definition scalar.h:112
unsigned int x
Definition scalar.h:115
unsigned int v[2]
Definition scalar.h:116
unsigned int y
Definition scalar.h:115
Definition scalar.h:121
unsigned int z
Definition scalar.h:124
unsigned int y
Definition scalar.h:124
unsigned int v[3]
Definition scalar.h:125
unsigned int x
Definition scalar.h:124
Definition scalar.h:130
unsigned int w
Definition scalar.h:133
unsigned int z
Definition scalar.h:133
unsigned int x
Definition scalar.h:133
unsigned int y
Definition scalar.h:133
unsigned int v[4]
Definition scalar.h:134
unsigned char ubyte
Definition types.h:34
uint64_t uint64
Definition types.h:36