Fix T60285: allow negative offsets in shrinkwrap (worked in 2.79).
[blender.git] / source / blender / blenlib / BLI_math_base.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: some of this file.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  * */
25
26 #ifndef __BLI_MATH_BASE_H__
27 #define __BLI_MATH_BASE_H__
28
29 /** \file BLI_math_base.h
30  *  \ingroup bli
31  */
32
33 #ifdef _MSC_VER
34 #  define _USE_MATH_DEFINES
35 #endif
36
37 #include <math.h>
38 #include "BLI_assert.h"
39 #include "BLI_math_inline.h"
40
41 #ifndef M_PI
42 #define M_PI        3.14159265358979323846  /* pi */
43 #endif
44 #ifndef M_PI_2
45 #define M_PI_2      1.57079632679489661923  /* pi/2 */
46 #endif
47 #ifndef M_PI_4
48 #define M_PI_4      0.78539816339744830962  /* pi/4 */
49 #endif
50 #ifndef M_SQRT2
51 #define M_SQRT2     1.41421356237309504880  /* sqrt(2) */
52 #endif
53 #ifndef M_SQRT1_2
54 #define M_SQRT1_2   0.70710678118654752440  /* 1/sqrt(2) */
55 #endif
56 #ifndef M_SQRT3
57 #define M_SQRT3     1.73205080756887729352  /* sqrt(3) */
58 #endif
59 #ifndef M_SQRT1_3
60 #define M_SQRT1_3   0.57735026918962576450  /* 1/sqrt(3) */
61 #endif
62 #ifndef M_1_PI
63 #define M_1_PI      0.318309886183790671538  /* 1/pi */
64 #endif
65 #ifndef M_E
66 #define M_E         2.7182818284590452354  /* e */
67 #endif
68 #ifndef M_LOG2E
69 #define M_LOG2E     1.4426950408889634074  /* log_2 e */
70 #endif
71 #ifndef M_LOG10E
72 #define M_LOG10E    0.43429448190325182765  /* log_10 e */
73 #endif
74 #ifndef M_LN2
75 #define M_LN2       0.69314718055994530942  /* log_e 2 */
76 #endif
77 #ifndef M_LN10
78 #define M_LN10      2.30258509299404568402  /* log_e 10 */
79 #endif
80
81 #if defined(__GNUC__)
82 #  define NAN_FLT __builtin_nanf("")
83 #else
84 /* evil quiet NaN definition */
85 static const int NAN_INT = 0x7FC00000;
86 #  define NAN_FLT  (*((float *)(&NAN_INT)))
87 #endif
88
89 #if BLI_MATH_DO_INLINE
90 #include "intern/math_base_inline.c"
91 #endif
92
93 #ifdef BLI_MATH_GCC_WARN_PRAGMA
94 #  pragma GCC diagnostic push
95 #  pragma GCC diagnostic ignored "-Wredundant-decls"
96 #endif
97
98 /******************************* Float ******************************/
99
100 MINLINE float pow2f(float x);
101 MINLINE float pow3f(float x);
102 MINLINE float pow4f(float x);
103 MINLINE float pow7f(float x);
104
105 MINLINE float sqrt3f(float f);
106 MINLINE double sqrt3d(double d);
107
108 MINLINE float sqrtf_signed(float f);
109
110 MINLINE float saacosf(float f);
111 MINLINE float saasinf(float f);
112 MINLINE float sasqrtf(float f);
113 MINLINE float saacos(float fac);
114 MINLINE float saasin(float fac);
115 MINLINE float sasqrt(float fac);
116
117 MINLINE float interpf(float a, float b, float t);
118
119 MINLINE float min_ff(float a, float b);
120 MINLINE float max_ff(float a, float b);
121 MINLINE float min_fff(float a, float b, float c);
122 MINLINE float max_fff(float a, float b, float c);
123 MINLINE float min_ffff(float a, float b, float c, float d);
124 MINLINE float max_ffff(float a, float b, float c, float d);
125
126 MINLINE int min_ii(int a, int b);
127 MINLINE int max_ii(int a, int b);
128 MINLINE int min_iii(int a, int b, int c);
129 MINLINE int max_iii(int a, int b, int c);
130 MINLINE int min_iiii(int a, int b, int c, int d);
131 MINLINE int max_iiii(int a, int b, int c, int d);
132
133 MINLINE size_t min_zz(size_t a, size_t b);
134 MINLINE size_t max_zz(size_t a, size_t b);
135
136 MINLINE int clamp_i(int value, int min, int max);
137 MINLINE float clamp_f(float value, float min, float max);
138 MINLINE size_t clamp_z(size_t value, size_t min, size_t max);
139
140 MINLINE int compare_ff(float a, float b, const float max_diff);
141 MINLINE int compare_ff_relative(float a, float b, const float max_diff, const int max_ulps);
142
143 MINLINE float signf(float f);
144 MINLINE int signum_i_ex(float a, float eps);
145 MINLINE int signum_i(float a);
146
147 MINLINE float power_of_2(float f);
148
149 MINLINE int integer_digits_f(const float f);
150 MINLINE int integer_digits_d(const double d);
151 MINLINE int integer_digits_i(const int i);
152
153 /* these don't really fit anywhere but were being copied about a lot */
154 MINLINE int is_power_of_2_i(int n);
155 MINLINE int power_of_2_max_i(int n);
156 MINLINE int power_of_2_min_i(int n);
157
158 MINLINE unsigned int power_of_2_max_u(unsigned int x);
159 MINLINE unsigned int power_of_2_min_u(unsigned int x);
160
161 MINLINE int divide_round_i(int a, int b);
162 MINLINE int mod_i(int i, int n);
163
164 MINLINE signed char    round_fl_to_char(float a);
165 MINLINE unsigned char  round_fl_to_uchar(float a);
166 MINLINE short          round_fl_to_short(float a);
167 MINLINE unsigned short round_fl_to_ushort(float a);
168 MINLINE int            round_fl_to_int(float a);
169 MINLINE unsigned int   round_fl_to_uint(float a);
170
171 MINLINE signed char    round_db_to_char(double a);
172 MINLINE unsigned char  round_db_to_uchar(double a);
173 MINLINE short          round_db_to_short(double a);
174 MINLINE unsigned short round_db_to_ushort(double a);
175 MINLINE int            round_db_to_int(double a);
176 MINLINE unsigned int   round_db_to_uint(double a);
177
178 MINLINE signed char    round_fl_to_char_clamp(float a);
179 MINLINE unsigned char  round_fl_to_uchar_clamp(float a);
180 MINLINE short          round_fl_to_short_clamp(float a);
181 MINLINE unsigned short round_fl_to_ushort_clamp(float a);
182 MINLINE int            round_fl_to_int_clamp(float a);
183 MINLINE unsigned int   round_fl_to_uint_clamp(float a);
184
185 MINLINE signed char    round_db_to_char_clamp(double a);
186 MINLINE unsigned char  round_db_to_uchar_clamp(double a);
187 MINLINE short          round_db_to_short_clamp(double a);
188 MINLINE unsigned short round_db_to_ushort_clamp(double a);
189 MINLINE int            round_db_to_int_clamp(double a);
190 MINLINE unsigned int   round_db_to_uint_clamp(double a);
191
192 int pow_i(int base, int exp);
193 double double_round(double x, int ndigits);
194
195 #ifdef BLI_MATH_GCC_WARN_PRAGMA
196 #  pragma GCC diagnostic pop
197 #endif
198
199 /* asserts, some math functions expect normalized inputs
200  * check the vector is unit length, or zero length (which can't be helped in some cases).
201  */
202 #ifndef NDEBUG
203 /** \note 0.0001 is too small becaues normals may be converted from short's: see T34322. */
204 #  define BLI_ASSERT_UNIT_EPSILON 0.0002f
205 /**
206  * \note Checks are flipped so NAN doesn't assert. This is done because we're making sure the value was normalized
207  * and in the case we don't want NAN to be raising asserts since there is nothing to be done in that case.
208  */
209 #  define BLI_ASSERT_UNIT_V3(v)  {                                            \
210         const float _test_unit = len_squared_v3(v);                               \
211         BLI_assert(!(fabsf(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON) ||      \
212                    !(fabsf(_test_unit)        >= BLI_ASSERT_UNIT_EPSILON));       \
213 } (void)0
214
215 #  define BLI_ASSERT_UNIT_V2(v)  {                                            \
216         const float _test_unit = len_squared_v2(v);                               \
217         BLI_assert(!(fabsf(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON) ||      \
218                    !(fabsf(_test_unit)        >= BLI_ASSERT_UNIT_EPSILON));       \
219 } (void)0
220
221 #  define BLI_ASSERT_UNIT_QUAT(q)  {                                          \
222         const float _test_unit = dot_qtqt(q, q);                                  \
223         BLI_assert(!(fabsf(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON * 10) || \
224                    !(fabsf(_test_unit)        >= BLI_ASSERT_UNIT_EPSILON * 10));  \
225 } (void)0
226
227 #  define BLI_ASSERT_ZERO_M3(m)  {                                            \
228         BLI_assert(dot_vn_vn((const float *)m, (const float *)m, 9) != 0.0);      \
229 } (void)0
230
231 #  define BLI_ASSERT_ZERO_M4(m)  {                                            \
232         BLI_assert(dot_vn_vn((const float *)m, (const float *)m, 16) != 0.0);     \
233 } (void)0
234 #  define BLI_ASSERT_UNIT_M3(m)  {                                            \
235         BLI_ASSERT_UNIT_V3((m)[0]);                                               \
236         BLI_ASSERT_UNIT_V3((m)[1]);                                               \
237         BLI_ASSERT_UNIT_V3((m)[2]);                                               \
238 } (void)0
239 #else
240 #  define BLI_ASSERT_UNIT_V2(v) (void)(v)
241 #  define BLI_ASSERT_UNIT_V3(v) (void)(v)
242 #  define BLI_ASSERT_UNIT_QUAT(v) (void)(v)
243 #  define BLI_ASSERT_ZERO_M3(m) (void)(m)
244 #  define BLI_ASSERT_ZERO_M4(m) (void)(m)
245 #  define BLI_ASSERT_UNIT_M3(m) (void)(m)
246 #endif
247
248 #endif /* __BLI_MATH_BASE_H__ */