add utility functions for dealing with planes
[blender.git] / source / blender / blenlib / intern / math_geom_inline.c
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 /** \file blender/blenlib/intern/math_geom_inline.c
27  *  \ingroup bli
28  */
29
30 #ifndef __MATH_GEOM_INLINE_C__
31 #define __MATH_GEOM_INLINE_C__
32
33 #include "BLI_math.h"
34
35 #include <string.h>
36
37 /****************************** Spherical Harmonics **************************/
38
39 MINLINE void zero_sh(float r[9])
40 {
41         memset(r, 0, sizeof(float) * 9);
42 }
43
44 MINLINE void copy_sh_sh(float r[9], const float a[9])
45 {
46         memcpy(r, a, sizeof(float) * 9);
47 }
48
49 MINLINE void mul_sh_fl(float r[9], const float f)
50 {
51         int i;
52
53         for (i = 0; i < 9; i++)
54                 r[i] *= f;
55 }
56
57 MINLINE void add_sh_shsh(float r[9], const float a[9], const float b[9])
58 {
59         int i;
60
61         for (i = 0; i < 9; i++)
62                 r[i] = a[i] + b[i];
63 }
64
65 MINLINE float dot_shsh(float a[9], float b[9])
66 {
67         float r = 0.0f;
68         int i;
69
70         for (i = 0; i < 9; i++)
71                 r += a[i] * b[i];
72
73         return r;
74 }
75
76 MINLINE float diffuse_shv3(float sh[9], const float v[3])
77 {
78         /* See formula (13) in:
79          * "An Efficient Representation for Irradiance Environment Maps" */
80         static const float c1 = 0.429043f, c2 = 0.511664f, c3 = 0.743125f;
81         static const float c4 = 0.886227f, c5 = 0.247708f;
82         float x, y, z, sum;
83
84         x = v[0];
85         y = v[1];
86         z = v[2];
87
88         sum = c1 * sh[8] * (x * x - y * y);
89         sum += c3 * sh[6] * z * z;
90         sum += c4 * sh[0];
91         sum += -c5 * sh[6];
92         sum += 2.0f * c1 * (sh[4] * x * y + sh[7] * x * z + sh[5] * y * z);
93         sum += 2.0f * c2 * (sh[3] * x + sh[1] * y + sh[2] * z);
94
95         return sum;
96 }
97
98 MINLINE void vec_fac_to_sh(float r[9], const float v[3], const float f)
99 {
100         /* See formula (3) in:
101          * "An Efficient Representation for Irradiance Environment Maps" */
102         float sh[9], x, y, z;
103
104         x = v[0];
105         y = v[1];
106         z = v[2];
107
108         sh[0] = 0.282095f;
109
110         sh[1] = 0.488603f * y;
111         sh[2] = 0.488603f * z;
112         sh[3] = 0.488603f * x;
113
114         sh[4] = 1.092548f * x * y;
115         sh[5] = 1.092548f * y * z;
116         sh[6] = 0.315392f * (3.0f * z * z - 1.0f);
117         sh[7] = 1.092548f * x * z;
118         sh[8] = 0.546274f * (x * x - y * y);
119
120         mul_sh_fl(sh, f);
121         copy_sh_sh(r, sh);
122 }
123
124 MINLINE float eval_shv3(float sh[9], const float v[3])
125 {
126         float tmp[9];
127
128         vec_fac_to_sh(tmp, v, 1.0f);
129         return dot_shsh(tmp, sh);
130 }
131
132 MINLINE void madd_sh_shfl(float r[9], const float sh[9], const float f)
133 {
134         float tmp[9];
135
136         copy_sh_sh(tmp, sh);
137         mul_sh_fl(tmp, f);
138         add_sh_shsh(r, r, tmp);
139 }
140
141 MINLINE int max_axis_v3(const float vec[3])
142 {
143         const float x = vec[0];
144         const float y = vec[1];
145         const float z = vec[2];
146         return ((x > y) ?
147                ((x > z) ? 0 : 2) :
148                ((y > z) ? 1 : 2));
149 }
150
151 MINLINE int min_axis_v3(const float vec[3])
152 {
153         const float x = vec[0];
154         const float y = vec[1];
155         const float z = vec[2];
156         return ((x < y) ?
157                ((x < z) ? 0 : 2) :
158                ((y < z) ? 1 : 2));
159 }
160
161 /**
162  * Simple method to find how many tri's we need when we already know the corner+poly count.
163  *
164  * Formula is:
165  *
166  *   tri = ((corner_count / poly_count) - 2) * poly_count;
167  *
168  * Use doubles since this is used for allocating and we
169  * don't want float precision to give incorrect results.
170  *
171  * \param poly_count The number of ngon's/tris (1-2 sided faces will give incorrect results)
172  * \param corner_count - also known as loops in BMesh/DNA
173  */
174 MINLINE int poly_to_tri_count(const int poly_count, const int corner_count)
175 {
176         if (poly_count != 0) {
177                 const double poly_count_d   = (double)poly_count;
178                 const double corner_count_d = (double)corner_count;
179                 BLI_assert(poly_count   > 0);
180                 BLI_assert(corner_count > 0);
181                 return (int)((((corner_count_d / poly_count_d) - 2.0) * poly_count_d) + 0.5);
182         }
183         else {
184                 return 0;
185         }
186 }
187
188 MINLINE float plane_point_side_v3(const float plane[4], const float co[3])
189 {
190         return dot_v3v3(co, plane) + plane[3];
191 }
192
193 #endif /* __MATH_GEOM_INLINE_C__ */