reduce float comparisons for keying operation and despill.
[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
31 #include "BLI_math.h"
32
33 #ifndef __MATH_GEOM_INLINE_C__
34 #define __MATH_GEOM_INLINE_C__
35
36 /****************************** Spherical Harmonics **************************/
37
38 MINLINE void zero_sh(float r[9])
39 {
40         memset(r, 0, sizeof(float) * 9);
41 }
42
43 MINLINE void copy_sh_sh(float r[9], const float a[9])
44 {
45         memcpy(r, a, sizeof(float) * 9);
46 }
47
48 MINLINE void mul_sh_fl(float r[9], const float f)
49 {
50         int i;
51
52         for (i = 0; i < 9; i++)
53                 r[i] *= f;
54 }
55
56 MINLINE void add_sh_shsh(float r[9], const float a[9], const float b[9])
57 {
58         int i;
59
60         for (i = 0; i < 9; i++)
61                 r[i] = a[i] + b[i];
62 }
63
64 MINLINE float dot_shsh(float a[9], float b[9])
65 {
66         float r = 0.0f;
67         int i;
68
69         for (i = 0; i < 9; i++)
70                 r += a[i] * b[i];
71
72         return r;
73 }
74
75 MINLINE float diffuse_shv3(float sh[9], const float v[3])
76 {
77         /* See formula (13) in:
78          * "An Efficient Representation for Irradiance Environment Maps" */
79         static const float c1 = 0.429043f, c2 = 0.511664f, c3 = 0.743125f;
80         static const float c4 = 0.886227f, c5 = 0.247708f;
81         float x, y, z, sum;
82
83         x = v[0];
84         y = v[1];
85         z = v[2];
86
87         sum = c1 * sh[8] * (x * x - y * y);
88         sum += c3 * sh[6] * z * z;
89         sum += c4 * sh[0];
90         sum += -c5 * sh[6];
91         sum += 2.0f * c1 * (sh[4] * x * y + sh[7] * x * z + sh[5] * y * z);
92         sum += 2.0f * c2 * (sh[3] * x + sh[1] * y + sh[2] * z);
93
94         return sum;
95 }
96
97 MINLINE void vec_fac_to_sh(float r[9], const float v[3], const float f)
98 {
99         /* See formula (3) in:
100          * "An Efficient Representation for Irradiance Environment Maps" */
101         float sh[9], x, y, z;
102
103         x = v[0];
104         y = v[1];
105         z = v[2];
106
107         sh[0] = 0.282095f;
108
109         sh[1] = 0.488603f * y;
110         sh[2] = 0.488603f * z;
111         sh[3] = 0.488603f * x;
112
113         sh[4] = 1.092548f * x * y;
114         sh[5] = 1.092548f * y * z;
115         sh[6] = 0.315392f * (3.0f * z * z - 1.0f);
116         sh[7] = 1.092548f * x * z;
117         sh[8] = 0.546274f * (x * x - y * y);
118
119         mul_sh_fl(sh, f);
120         copy_sh_sh(r, sh);
121 }
122
123 MINLINE float eval_shv3(float sh[9], const float v[3])
124 {
125         float tmp[9];
126
127         vec_fac_to_sh(tmp, v, 1.0f);
128         return dot_shsh(tmp, sh);
129 }
130
131 MINLINE void madd_sh_shfl(float r[9], const float sh[9], const float f)
132 {
133         float tmp[9];
134
135         copy_sh_sh(tmp, sh);
136         mul_sh_fl(tmp, f);
137         add_sh_shsh(r, r, tmp);
138 }
139
140 MINLINE int axis_primary_v3(const float vec[3])
141 {
142         const float x = vec[0];
143         const float y = vec[1];
144         const float z = vec[2];
145
146         if (x > y) {
147                 if (x > z) {
148                         return 0;
149                 }
150                 else {
151                         return 2;
152                 }
153         }
154         else {
155                 if (y > z) {
156                         return 1;
157                 }
158                 else {
159                         return 2;
160                 }
161         }
162 }
163
164 #endif /* __MATH_GEOM_INLINE_C__ */