Cycles: Implement denoising option for reducing noise in the rendered image
[blender.git] / intern / cycles / util / util_math_float3.h
1 /*
2  * Copyright 2011-2017 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __UTIL_MATH_FLOAT3_H__
18 #define __UTIL_MATH_FLOAT3_H__
19
20 #ifndef __UTIL_MATH_H__
21 #  error "Do not include this file directly, include util_types.h instead."
22 #endif
23
24 CCL_NAMESPACE_BEGIN
25
26 /*******************************************************************************
27  * Declaration.
28  */
29
30 #ifndef __KERNEL_OPENCL__
31 ccl_device_inline float3 operator-(const float3& a);
32 ccl_device_inline float3 operator*(const float3& a, const float3& b);
33 ccl_device_inline float3 operator*(const float3& a, const float f);
34 ccl_device_inline float3 operator*(const float f, const float3& a);
35 ccl_device_inline float3 operator/(const float f, const float3& a);
36 ccl_device_inline float3 operator/(const float3& a, const float f);
37 ccl_device_inline float3 operator/(const float3& a, const float3& b);
38 ccl_device_inline float3 operator+(const float3& a, const float3& b);
39 ccl_device_inline float3 operator-(const float3& a, const float3& b);
40 ccl_device_inline float3 operator+=(float3& a, const float3& b);
41 ccl_device_inline float3 operator-=(float3& a, const float3& b);
42 ccl_device_inline float3 operator*=(float3& a, const float3& b);
43 ccl_device_inline float3 operator*=(float3& a, float f);
44 ccl_device_inline float3 operator/=(float3& a, const float3& b);
45 ccl_device_inline float3 operator/=(float3& a, float f);
46
47 ccl_device_inline bool operator==(const float3& a, const float3& b);
48 ccl_device_inline bool operator!=(const float3& a, const float3& b);
49
50 ccl_device_inline float dot(const float3& a, const float3& b);
51 ccl_device_inline float dot_xy(const float3& a, const float3& b);
52 ccl_device_inline float3 cross(const float3& a, const float3& b);
53 ccl_device_inline float3 normalize(const float3& a);
54 ccl_device_inline float3 min(const float3& a, const float3& b);
55 ccl_device_inline float3 max(const float3& a, const float3& b);
56 ccl_device_inline float3 clamp(const float3& a, const float3& mn, const float3& mx);
57 ccl_device_inline float3 fabs(const float3& a);
58 ccl_device_inline float3 mix(const float3& a, const float3& b, float t);
59 ccl_device_inline float3 rcp(const float3& a);
60 #endif  /* !__KERNEL_OPENCL__ */
61
62 ccl_device_inline float max3(float3 a);
63 ccl_device_inline float len(const float3 a);
64 ccl_device_inline float len_squared(const float3 a);
65
66 ccl_device_inline float3 saturate3(float3 a);
67 ccl_device_inline float3 safe_normalize(const float3 a);
68 ccl_device_inline float3 normalize_len(const float3 a, float *t);;
69 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t);
70 ccl_device_inline float3 interp(float3 a, float3 b, float t);
71
72 ccl_device_inline bool is_zero(const float3 a);
73 ccl_device_inline float reduce_add(const float3 a);
74 ccl_device_inline float average(const float3 a);
75 ccl_device_inline bool isequal_float3(const float3 a, const float3 b);
76
77 /*******************************************************************************
78  * Definition.
79  */
80
81 #ifndef __KERNEL_OPENCL__
82 ccl_device_inline float3 operator-(const float3& a)
83 {
84 #ifdef __KERNEL_SSE__
85         return float3(_mm_xor_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x80000000))));
86 #else
87         return make_float3(-a.x, -a.y, -a.z);
88 #endif
89 }
90
91 ccl_device_inline float3 operator*(const float3& a, const float3& b)
92 {
93 #ifdef __KERNEL_SSE__
94         return float3(_mm_mul_ps(a.m128,b.m128));
95 #else
96         return make_float3(a.x*b.x, a.y*b.y, a.z*b.z);
97 #endif
98 }
99
100 ccl_device_inline float3 operator*(const float3& a, const float f)
101 {
102 #ifdef __KERNEL_SSE__
103         return float3(_mm_mul_ps(a.m128,_mm_set1_ps(f)));
104 #else
105         return make_float3(a.x*f, a.y*f, a.z*f);
106 #endif
107 }
108
109 ccl_device_inline float3 operator*(const float f, const float3& a)
110 {
111         /* TODO(sergey): Currently disabled, gives speedup but causes precision issues. */
112 #if defined(__KERNEL_SSE__) && 0
113         return float3(_mm_mul_ps(_mm_set1_ps(f), a.m128));
114 #else
115         return make_float3(a.x*f, a.y*f, a.z*f);
116 #endif
117 }
118
119 ccl_device_inline float3 operator/(const float f, const float3& a)
120 {
121         /* TODO(sergey): Currently disabled, gives speedup but causes precision issues. */
122 #if defined(__KERNEL_SSE__) && 0
123         __m128 rc = _mm_rcp_ps(a.m128);
124         return float3(_mm_mul_ps(_mm_set1_ps(f),rc));
125 #else
126         return make_float3(f / a.x, f / a.y, f / a.z);
127 #endif
128 }
129
130 ccl_device_inline float3 operator/(const float3& a, const float f)
131 {
132         float invf = 1.0f/f;
133         return a * invf;
134 }
135
136 ccl_device_inline float3 operator/(const float3& a, const float3& b)
137 {
138         /* TODO(sergey): Currently disabled, gives speedup but causes precision issues. */
139 #if defined(__KERNEL_SSE__) && 0
140         __m128 rc = _mm_rcp_ps(b.m128);
141         return float3(_mm_mul_ps(a, rc));
142 #else
143         return make_float3(a.x / b.x, a.y / b.y, a.z / b.z);
144 #endif
145 }
146
147 ccl_device_inline float3 operator+(const float3& a, const float3& b)
148 {
149 #ifdef __KERNEL_SSE__
150         return float3(_mm_add_ps(a.m128, b.m128));
151 #else
152         return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
153 #endif
154 }
155
156 ccl_device_inline float3 operator-(const float3& a, const float3& b)
157 {
158 #ifdef __KERNEL_SSE__
159         return float3(_mm_sub_ps(a.m128, b.m128));
160 #else
161         return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
162 #endif
163 }
164
165 ccl_device_inline float3 operator+=(float3& a, const float3& b)
166 {
167         return a = a + b;
168 }
169
170 ccl_device_inline float3 operator-=(float3& a, const float3& b)
171 {
172         return a = a - b;
173 }
174
175 ccl_device_inline float3 operator*=(float3& a, const float3& b)
176 {
177         return a = a * b;
178 }
179
180 ccl_device_inline float3 operator*=(float3& a, float f)
181 {
182         return a = a * f;
183 }
184
185 ccl_device_inline float3 operator/=(float3& a, const float3& b)
186 {
187         return a = a / b;
188 }
189
190 ccl_device_inline float3 operator/=(float3& a, float f)
191 {
192         float invf = 1.0f/f;
193         return a = a * invf;
194 }
195
196 ccl_device_inline bool operator==(const float3& a, const float3& b)
197 {
198 #ifdef __KERNEL_SSE__
199         return (_mm_movemask_ps(_mm_cmpeq_ps(a.m128, b.m128)) & 7) == 7;
200 #else
201         return (a.x == b.x && a.y == b.y && a.z == b.z);
202 #endif
203 }
204
205 ccl_device_inline bool operator!=(const float3& a, const float3& b)
206 {
207         return !(a == b);
208 }
209
210 ccl_device_inline float dot(const float3& a, const float3& b)
211 {
212 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
213         return _mm_cvtss_f32(_mm_dp_ps(a, b, 0x7F));
214 #else
215         return a.x*b.x + a.y*b.y + a.z*b.z;
216 #endif
217 }
218
219 ccl_device_inline float dot_xy(const float3& a, const float3& b)
220 {
221 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
222         return _mm_cvtss_f32(_mm_hadd_ps(_mm_mul_ps(a,b),b));
223 #else
224         return a.x*b.x + a.y*b.y;
225 #endif
226 }
227
228 ccl_device_inline float3 cross(const float3& a, const float3& b)
229 {
230         float3 r = make_float3(a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x);
231         return r;
232 }
233
234 ccl_device_inline float3 normalize(const float3& a)
235 {
236 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
237         __m128 norm = _mm_sqrt_ps(_mm_dp_ps(a.m128, a.m128, 0x7F));
238         return float3(_mm_div_ps(a.m128, norm));
239 #else
240         return a/len(a);
241 #endif
242 }
243
244 ccl_device_inline float3 min(const float3& a, const float3& b)
245 {
246 #ifdef __KERNEL_SSE__
247         return float3(_mm_min_ps(a.m128, b.m128));
248 #else
249         return make_float3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
250 #endif
251 }
252
253 ccl_device_inline float3 max(const float3& a, const float3& b)
254 {
255 #ifdef __KERNEL_SSE__
256         return float3(_mm_max_ps(a.m128, b.m128));
257 #else
258         return make_float3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
259 #endif
260 }
261
262 ccl_device_inline float3 clamp(const float3& a, const float3& mn, const float3& mx)
263 {
264         return min(max(a, mn), mx);
265 }
266
267 ccl_device_inline float3 fabs(const float3& a)
268 {
269 #ifdef __KERNEL_SSE__
270         __m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff));
271         return float3(_mm_and_ps(a.m128, mask));
272 #else
273         return make_float3(fabsf(a.x), fabsf(a.y), fabsf(a.z));
274 #endif
275 }
276
277 ccl_device_inline float3 mix(const float3& a, const float3& b, float t)
278 {
279         return a + t*(b - a);
280 }
281
282 ccl_device_inline float3 rcp(const float3& a)
283 {
284 #ifdef __KERNEL_SSE__
285         const float4 r(_mm_rcp_ps(a.m128));
286         return float3(_mm_sub_ps(_mm_add_ps(r, r),
287                                  _mm_mul_ps(_mm_mul_ps(r, r), a)));
288 #else
289         return make_float3(1.0f/a.x, 1.0f/a.y, 1.0f/a.z);
290 #endif
291 }
292 #endif  /* !__KERNEL_OPENCL__ */
293
294 ccl_device_inline float max3(float3 a)
295 {
296         return max(max(a.x, a.y), a.z);
297 }
298
299 ccl_device_inline float len(const float3 a)
300 {
301 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
302         return _mm_cvtss_f32(_mm_sqrt_ss(_mm_dp_ps(a.m128, a.m128, 0x7F)));
303 #else
304         return sqrtf(dot(a, a));
305 #endif
306 }
307
308 ccl_device_inline float len_squared(const float3 a)
309 {
310         return dot(a, a);
311 }
312
313 ccl_device_inline float3 saturate3(float3 a)
314 {
315         return make_float3(saturate(a.x), saturate(a.y), saturate(a.z));
316 }
317
318 ccl_device_inline float3 normalize_len(const float3 a, float *t)
319 {
320         *t = len(a);
321         float x = 1.0f / *t;
322         return a*x;
323 }
324
325 ccl_device_inline float3 safe_normalize(const float3 a)
326 {
327         float t = len(a);
328         return (t != 0.0f)? a * (1.0f/t) : a;
329 }
330
331 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t)
332 {
333         *t = len(a);
334         return (*t != 0.0f)? a/(*t): a;
335 }
336
337 ccl_device_inline float3 interp(float3 a, float3 b, float t)
338 {
339         return a + t*(b - a);
340 }
341
342 ccl_device_inline bool is_zero(const float3 a)
343 {
344 #ifdef __KERNEL_SSE__
345         return a == make_float3(0.0f);
346 #else
347         return (a.x == 0.0f && a.y == 0.0f && a.z == 0.0f);
348 #endif
349 }
350
351 ccl_device_inline float reduce_add(const float3 a)
352 {
353         return (a.x + a.y + a.z);
354 }
355
356 ccl_device_inline float average(const float3 a)
357 {
358         return reduce_add(a)*(1.0f/3.0f);
359 }
360
361 ccl_device_inline bool isequal_float3(const float3 a, const float3 b)
362 {
363 #ifdef __KERNEL_OPENCL__
364         return all(a == b);
365 #else
366         return a == b;
367 #endif
368 }
369
370 ccl_device_inline float3 ensure_finite3(float3 v)
371 {
372         if(!isfinite_safe(v.x)) v.x = 0.0;
373         if(!isfinite_safe(v.y)) v.y = 0.0;
374         if(!isfinite_safe(v.z)) v.z = 0.0;
375         return v;
376 }
377
378 CCL_NAMESPACE_END
379
380 #endif /* __UTIL_MATH_FLOAT3_H__ */