Cleanup: remove redundant, invalid info from headers
[blender.git] / source / blender / blenlib / intern / math_geom_inline.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  *
19  * The Original Code is: some of this file.
20  *
21  * */
22
23 /** \file blender/blenlib/intern/math_geom_inline.c
24  *  \ingroup bli
25  */
26
27 #ifndef __MATH_GEOM_INLINE_C__
28 #define __MATH_GEOM_INLINE_C__
29
30 #include "BLI_math.h"
31
32 #include <string.h>
33
34 /* A few small defines. Keep'em local! */
35 #define SMALL_NUMBER  1.e-8f
36
37 /********************************** Polygons *********************************/
38
39 MINLINE float cross_tri_v2(const float v1[2], const float v2[2], const float v3[2])
40 {
41         return (v1[0] - v2[0]) * (v2[1] - v3[1]) + (v1[1] - v2[1]) * (v3[0] - v2[0]);
42 }
43
44 MINLINE float area_tri_signed_v2(const float v1[2], const float v2[2], const float v3[2])
45 {
46         return 0.5f * ((v1[0] - v2[0]) * (v2[1] - v3[1]) + (v1[1] - v2[1]) * (v3[0] - v2[0]));
47 }
48
49 MINLINE float area_tri_v2(const float v1[2], const float v2[2], const float v3[2])
50 {
51         return fabsf(area_tri_signed_v2(v1, v2, v3));
52 }
53
54 MINLINE float area_squared_tri_v2(const float v1[2], const float v2[2], const float v3[2])
55 {
56         float area = area_tri_signed_v2(v1, v2, v3);
57         return area * area;
58 }
59
60 /****************************** Spherical Harmonics **************************/
61
62 MINLINE void zero_sh(float r[9])
63 {
64         memset(r, 0, sizeof(float) * 9);
65 }
66
67 MINLINE void copy_sh_sh(float r[9], const float a[9])
68 {
69         memcpy(r, a, sizeof(float) * 9);
70 }
71
72 MINLINE void mul_sh_fl(float r[9], const float f)
73 {
74         int i;
75
76         for (i = 0; i < 9; i++)
77                 r[i] *= f;
78 }
79
80 MINLINE void add_sh_shsh(float r[9], const float a[9], const float b[9])
81 {
82         int i;
83
84         for (i = 0; i < 9; i++)
85                 r[i] = a[i] + b[i];
86 }
87
88 MINLINE float dot_shsh(const float a[9], const float b[9])
89 {
90         float r = 0.0f;
91         int i;
92
93         for (i = 0; i < 9; i++)
94                 r += a[i] * b[i];
95
96         return r;
97 }
98
99 MINLINE float diffuse_shv3(float sh[9], const float v[3])
100 {
101         /* See formula (13) in:
102          * "An Efficient Representation for Irradiance Environment Maps" */
103         static const float c1 = 0.429043f, c2 = 0.511664f, c3 = 0.743125f;
104         static const float c4 = 0.886227f, c5 = 0.247708f;
105         float x, y, z, sum;
106
107         x = v[0];
108         y = v[1];
109         z = v[2];
110
111         sum = c1 * sh[8] * (x * x - y * y);
112         sum += c3 * sh[6] * z * z;
113         sum += c4 * sh[0];
114         sum += -c5 * sh[6];
115         sum += 2.0f * c1 * (sh[4] * x * y + sh[7] * x * z + sh[5] * y * z);
116         sum += 2.0f * c2 * (sh[3] * x + sh[1] * y + sh[2] * z);
117
118         return sum;
119 }
120
121 MINLINE void vec_fac_to_sh(float r[9], const float v[3], const float f)
122 {
123         /* See formula (3) in:
124          * "An Efficient Representation for Irradiance Environment Maps" */
125         float sh[9], x, y, z;
126
127         x = v[0];
128         y = v[1];
129         z = v[2];
130
131         sh[0] = 0.282095f;
132
133         sh[1] = 0.488603f * y;
134         sh[2] = 0.488603f * z;
135         sh[3] = 0.488603f * x;
136
137         sh[4] = 1.092548f * x * y;
138         sh[5] = 1.092548f * y * z;
139         sh[6] = 0.315392f * (3.0f * z * z - 1.0f);
140         sh[7] = 1.092548f * x * z;
141         sh[8] = 0.546274f * (x * x - y * y);
142
143         mul_sh_fl(sh, f);
144         copy_sh_sh(r, sh);
145 }
146
147 MINLINE float eval_shv3(float sh[9], const float v[3])
148 {
149         float tmp[9];
150
151         vec_fac_to_sh(tmp, v, 1.0f);
152         return dot_shsh(tmp, sh);
153 }
154
155 MINLINE void madd_sh_shfl(float r[9], const float sh[9], const float f)
156 {
157         float tmp[9];
158
159         copy_sh_sh(tmp, sh);
160         mul_sh_fl(tmp, f);
161         add_sh_shsh(r, r, tmp);
162 }
163
164 /* get the 2 dominant axis values, 0==X, 1==Y, 2==Z */
165 MINLINE void axis_dominant_v3(int *r_axis_a, int *r_axis_b, const float axis[3])
166 {
167         const float xn = fabsf(axis[0]);
168         const float yn = fabsf(axis[1]);
169         const float zn = fabsf(axis[2]);
170
171         if      (zn >= xn && zn >= yn) { *r_axis_a = 0; *r_axis_b = 1; }
172         else if (yn >= xn && yn >= zn) { *r_axis_a = 0; *r_axis_b = 2; }
173         else                           { *r_axis_a = 1; *r_axis_b = 2; }
174 }
175
176 /* same as axis_dominant_v3 but return the max value */
177 MINLINE float axis_dominant_v3_max(int *r_axis_a, int *r_axis_b, const float axis[3])
178 {
179         const float xn = fabsf(axis[0]);
180         const float yn = fabsf(axis[1]);
181         const float zn = fabsf(axis[2]);
182
183         if      (zn >= xn && zn >= yn) { *r_axis_a = 0; *r_axis_b = 1; return zn; }
184         else if (yn >= xn && yn >= zn) { *r_axis_a = 0; *r_axis_b = 2; return yn; }
185         else                           { *r_axis_a = 1; *r_axis_b = 2; return xn; }
186 }
187
188 /* get the single dominant axis value, 0==X, 1==Y, 2==Z */
189 MINLINE int axis_dominant_v3_single(const float vec[3])
190 {
191         const float x = fabsf(vec[0]);
192         const float y = fabsf(vec[1]);
193         const float z = fabsf(vec[2]);
194         return ((x > y) ?
195                ((x > z) ? 0 : 2) :
196                ((y > z) ? 1 : 2));
197 }
198
199 /* the dominant axis of an orthogonal vector */
200 MINLINE int axis_dominant_v3_ortho_single(const float vec[3])
201 {
202         const float x = fabsf(vec[0]);
203         const float y = fabsf(vec[1]);
204         const float z = fabsf(vec[2]);
205         return ((x < y) ?
206                ((x < z) ? 0 : 2) :
207                ((y < z) ? 1 : 2));
208 }
209
210 MINLINE int max_axis_v3(const float vec[3])
211 {
212         const float x = vec[0];
213         const float y = vec[1];
214         const float z = vec[2];
215         return ((x > y) ?
216                ((x > z) ? 0 : 2) :
217                ((y > z) ? 1 : 2));
218 }
219
220 MINLINE int min_axis_v3(const float vec[3])
221 {
222         const float x = vec[0];
223         const float y = vec[1];
224         const float z = vec[2];
225         return ((x < y) ?
226                ((x < z) ? 0 : 2) :
227                ((y < z) ? 1 : 2));
228 }
229
230 /**
231  * Simple method to find how many tri's we need when we already know the corner+poly count.
232  *
233  * \param poly_count: The number of ngon's/tris (1-2 sided faces will give incorrect results)
234  * \param corner_count: also known as loops in BMesh/DNA
235  */
236 MINLINE int poly_to_tri_count(const int poly_count, const int corner_count)
237 {
238         BLI_assert(!poly_count || corner_count > poly_count * 2);
239         return corner_count - (poly_count * 2);
240 }
241
242 MINLINE float plane_point_side_v3(const float plane[4], const float co[3])
243 {
244         return dot_v3v3(co, plane) + plane[3];
245 }
246
247 /* useful to calculate an even width shell, by taking the angle between 2 planes.
248  * The return value is a scale on the offset.
249  * no angle between planes is 1.0, as the angle between the 2 planes approaches 180d
250  * the distance gets very high, 180d would be inf, but this case isn't valid */
251 MINLINE float shell_angle_to_dist(const float angle)
252 {
253         return (UNLIKELY(angle < SMALL_NUMBER)) ? 1.0f : fabsf(1.0f / cosf(angle));
254 }
255 /**
256  * equivalent to ``shell_angle_to_dist(angle_normalized_v3v3(a, b))``
257  */
258 MINLINE float shell_v3v3_normalized_to_dist(const float a[3], const float b[3])
259 {
260         const float angle_cos = fabsf(dot_v3v3(a, b));
261         BLI_ASSERT_UNIT_V3(a);
262         BLI_ASSERT_UNIT_V3(b);
263         return (UNLIKELY(angle_cos < SMALL_NUMBER)) ? 1.0f : (1.0f / angle_cos);
264 }
265 /**
266  * equivalent to ``shell_angle_to_dist(angle_normalized_v2v2(a, b))``
267  */
268 MINLINE float shell_v2v2_normalized_to_dist(const float a[2], const float b[2])
269 {
270         const float angle_cos = fabsf(dot_v2v2(a, b));
271         BLI_ASSERT_UNIT_V2(a);
272         BLI_ASSERT_UNIT_V2(b);
273         return (UNLIKELY(angle_cos < SMALL_NUMBER)) ? 1.0f : (1.0f / angle_cos);
274 }
275
276 /**
277  * equivalent to ``shell_angle_to_dist(angle_normalized_v3v3(a, b) / 2)``
278  */
279 MINLINE float shell_v3v3_mid_normalized_to_dist(const float a[3], const float b[3])
280 {
281         float angle_cos;
282         float ab[3];
283         BLI_ASSERT_UNIT_V3(a);
284         BLI_ASSERT_UNIT_V3(b);
285         add_v3_v3v3(ab, a, b);
286         angle_cos = (normalize_v3(ab) != 0.0f) ? fabsf(dot_v3v3(a, ab)) : 0.0f;
287         return (UNLIKELY(angle_cos < SMALL_NUMBER)) ? 1.0f : (1.0f / angle_cos);
288 }
289
290 /**
291  * equivalent to ``shell_angle_to_dist(angle_normalized_v2v2(a, b) / 2)``
292  */
293 MINLINE float shell_v2v2_mid_normalized_to_dist(const float a[2], const float b[2])
294 {
295         float angle_cos;
296         float ab[2];
297         BLI_ASSERT_UNIT_V2(a);
298         BLI_ASSERT_UNIT_V2(b);
299         add_v2_v2v2(ab, a, b);
300         angle_cos = (normalize_v2(ab) != 0.0f) ? fabsf(dot_v2v2(a, ab)) : 0.0f;
301         return (UNLIKELY(angle_cos < SMALL_NUMBER)) ? 1.0f : (1.0f / angle_cos);
302 }
303
304 #undef SMALL_NUMBER
305
306 #endif /* __MATH_GEOM_INLINE_C__ */