Cycles: random walk subsurface scattering.
[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 min3(float3 a);
63 ccl_device_inline float max3(float3 a);
64 ccl_device_inline float len(const float3 a);
65 ccl_device_inline float len_squared(const float3 a);
66
67 ccl_device_inline float3 saturate3(float3 a);
68 ccl_device_inline float3 safe_normalize(const float3 a);
69 ccl_device_inline float3 normalize_len(const float3 a, float *t);;
70 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t);
71 ccl_device_inline float3 interp(float3 a, float3 b, float t);
72
73 ccl_device_inline bool is_zero(const float3 a);
74 ccl_device_inline float reduce_add(const float3 a);
75 ccl_device_inline float average(const float3 a);
76 ccl_device_inline bool isequal_float3(const float3 a, const float3 b);
77
78 /*******************************************************************************
79  * Definition.
80  */
81
82 #ifndef __KERNEL_OPENCL__
83 ccl_device_inline float3 operator-(const float3& a)
84 {
85 #ifdef __KERNEL_SSE__
86         return float3(_mm_xor_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x80000000))));
87 #else
88         return make_float3(-a.x, -a.y, -a.z);
89 #endif
90 }
91
92 ccl_device_inline float3 operator*(const float3& a, const float3& b)
93 {
94 #ifdef __KERNEL_SSE__
95         return float3(_mm_mul_ps(a.m128,b.m128));
96 #else
97         return make_float3(a.x*b.x, a.y*b.y, a.z*b.z);
98 #endif
99 }
100
101 ccl_device_inline float3 operator*(const float3& a, const float f)
102 {
103 #ifdef __KERNEL_SSE__
104         return float3(_mm_mul_ps(a.m128,_mm_set1_ps(f)));
105 #else
106         return make_float3(a.x*f, a.y*f, a.z*f);
107 #endif
108 }
109
110 ccl_device_inline float3 operator*(const float f, const float3& a)
111 {
112 #if defined(__KERNEL_SSE__)
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 #if defined(__KERNEL_SSE__)
122         return float3(_mm_div_ps(_mm_set1_ps(f), a.m128));
123 #else
124         return make_float3(f / a.x, f / a.y, f / a.z);
125 #endif
126 }
127
128 ccl_device_inline float3 operator/(const float3& a, const float f)
129 {
130         float invf = 1.0f/f;
131         return a * invf;
132 }
133
134 ccl_device_inline float3 operator/(const float3& a, const float3& b)
135 {
136 #if defined(__KERNEL_SSE__)
137         return float3(_mm_div_ps(a.m128, b.m128));
138 #else
139         return make_float3(a.x / b.x, a.y / b.y, a.z / b.z);
140 #endif
141 }
142
143 ccl_device_inline float3 operator+(const float3& a, const float3& b)
144 {
145 #ifdef __KERNEL_SSE__
146         return float3(_mm_add_ps(a.m128, b.m128));
147 #else
148         return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
149 #endif
150 }
151
152 ccl_device_inline float3 operator-(const float3& a, const float3& b)
153 {
154 #ifdef __KERNEL_SSE__
155         return float3(_mm_sub_ps(a.m128, b.m128));
156 #else
157         return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
158 #endif
159 }
160
161 ccl_device_inline float3 operator+=(float3& a, const float3& b)
162 {
163         return a = a + b;
164 }
165
166 ccl_device_inline float3 operator-=(float3& a, const float3& b)
167 {
168         return a = a - b;
169 }
170
171 ccl_device_inline float3 operator*=(float3& a, const float3& b)
172 {
173         return a = a * b;
174 }
175
176 ccl_device_inline float3 operator*=(float3& a, float f)
177 {
178         return a = a * f;
179 }
180
181 ccl_device_inline float3 operator/=(float3& a, const float3& b)
182 {
183         return a = a / b;
184 }
185
186 ccl_device_inline float3 operator/=(float3& a, float f)
187 {
188         float invf = 1.0f/f;
189         return a = a * invf;
190 }
191
192 ccl_device_inline bool operator==(const float3& a, const float3& b)
193 {
194 #ifdef __KERNEL_SSE__
195         return (_mm_movemask_ps(_mm_cmpeq_ps(a.m128, b.m128)) & 7) == 7;
196 #else
197         return (a.x == b.x && a.y == b.y && a.z == b.z);
198 #endif
199 }
200
201 ccl_device_inline bool operator!=(const float3& a, const float3& b)
202 {
203         return !(a == b);
204 }
205
206 ccl_device_inline float dot(const float3& a, const float3& b)
207 {
208 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
209         return _mm_cvtss_f32(_mm_dp_ps(a, b, 0x7F));
210 #else
211         return a.x*b.x + a.y*b.y + a.z*b.z;
212 #endif
213 }
214
215 ccl_device_inline float dot_xy(const float3& a, const float3& b)
216 {
217 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
218         return _mm_cvtss_f32(_mm_hadd_ps(_mm_mul_ps(a,b),b));
219 #else
220         return a.x*b.x + a.y*b.y;
221 #endif
222 }
223
224 ccl_device_inline float3 cross(const float3& a, const float3& b)
225 {
226         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);
227         return r;
228 }
229
230 ccl_device_inline float3 normalize(const float3& a)
231 {
232 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
233         __m128 norm = _mm_sqrt_ps(_mm_dp_ps(a.m128, a.m128, 0x7F));
234         return float3(_mm_div_ps(a.m128, norm));
235 #else
236         return a/len(a);
237 #endif
238 }
239
240 ccl_device_inline float3 min(const float3& a, const float3& b)
241 {
242 #ifdef __KERNEL_SSE__
243         return float3(_mm_min_ps(a.m128, b.m128));
244 #else
245         return make_float3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
246 #endif
247 }
248
249 ccl_device_inline float3 max(const float3& a, const float3& b)
250 {
251 #ifdef __KERNEL_SSE__
252         return float3(_mm_max_ps(a.m128, b.m128));
253 #else
254         return make_float3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
255 #endif
256 }
257
258 ccl_device_inline float3 clamp(const float3& a, const float3& mn, const float3& mx)
259 {
260         return min(max(a, mn), mx);
261 }
262
263 ccl_device_inline float3 fabs(const float3& a)
264 {
265 #ifdef __KERNEL_SSE__
266         __m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff));
267         return float3(_mm_and_ps(a.m128, mask));
268 #else
269         return make_float3(fabsf(a.x), fabsf(a.y), fabsf(a.z));
270 #endif
271 }
272
273 ccl_device_inline float3 mix(const float3& a, const float3& b, float t)
274 {
275         return a + t*(b - a);
276 }
277
278 ccl_device_inline float3 rcp(const float3& a)
279 {
280 #ifdef __KERNEL_SSE__
281         /* Don't use _mm_rcp_ps due to poor precision. */
282         return float3(_mm_div_ps(_mm_set_ps1(1.0f), a.m128));
283 #else
284         return make_float3(1.0f/a.x, 1.0f/a.y, 1.0f/a.z);
285 #endif
286 }
287 #endif  /* !__KERNEL_OPENCL__ */
288
289 ccl_device_inline float min3(float3 a)
290 {
291         return min(min(a.x, a.y), a.z);
292 }
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 bool isfinite3_safe(float3 v)
371 {
372         return isfinite_safe(v.x) && isfinite_safe(v.y) && isfinite_safe(v.z);
373 }
374
375 ccl_device_inline float3 ensure_finite3(float3 v)
376 {
377         if(!isfinite_safe(v.x)) v.x = 0.0f;
378         if(!isfinite_safe(v.y)) v.y = 0.0f;
379         if(!isfinite_safe(v.z)) v.z = 0.0f;
380         return v;
381 }
382
383 CCL_NAMESPACE_END
384
385 #endif /* __UTIL_MATH_FLOAT3_H__ */