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 float f);
39 ccl_device_inline float3 operator+(const float3 &a, const float3 &b);
40 ccl_device_inline float3 operator-(const float3 &a, const float f);
41 ccl_device_inline float3 operator-(const float3 &a, const float3 &b);
42 ccl_device_inline float3 operator+=(float3 &a, const float3 &b);
43 ccl_device_inline float3 operator-=(float3 &a, const float3 &b);
44 ccl_device_inline float3 operator*=(float3 &a, const float3 &b);
45 ccl_device_inline float3 operator*=(float3 &a, float f);
46 ccl_device_inline float3 operator/=(float3 &a, const float3 &b);
47 ccl_device_inline float3 operator/=(float3 &a, float f);
48
49 ccl_device_inline bool operator==(const float3 &a, const float3 &b);
50 ccl_device_inline bool operator!=(const float3 &a, const float3 &b);
51
52 ccl_device_inline float distance(const float3 &a, const float3 &b);
53 ccl_device_inline float dot(const float3 &a, const float3 &b);
54 ccl_device_inline float dot_xy(const float3 &a, const float3 &b);
55 ccl_device_inline float3 cross(const float3 &a, const float3 &b);
56 ccl_device_inline float3 normalize(const float3 &a);
57 ccl_device_inline float3 min(const float3 &a, const float3 &b);
58 ccl_device_inline float3 max(const float3 &a, const float3 &b);
59 ccl_device_inline float3 clamp(const float3 &a, const float3 &mn, const float3 &mx);
60 ccl_device_inline float3 fabs(const float3 &a);
61 ccl_device_inline float3 mix(const float3 &a, const float3 &b, float t);
62 ccl_device_inline float3 rcp(const float3 &a);
63 ccl_device_inline float3 sqrt(const float3 &a);
64 ccl_device_inline float3 floor(const float3 &a);
65 ccl_device_inline float3 ceil(const float3 &a);
66 #endif /* !__KERNEL_OPENCL__ */
67
68 ccl_device_inline float min3(float3 a);
69 ccl_device_inline float max3(float3 a);
70 ccl_device_inline float len(const float3 a);
71 ccl_device_inline float len_squared(const float3 a);
72
73 ccl_device_inline float3 reflect(const float3 incident, const float3 normal);
74 ccl_device_inline float3 project(const float3 v, const float3 v_proj);
75
76 ccl_device_inline float3 saturate3(float3 a);
77 ccl_device_inline float3 safe_normalize(const float3 a);
78 ccl_device_inline float3 normalize_len(const float3 a, float *t);
79 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t);
80 ccl_device_inline float3 safe_divide_float3_float3(const float3 a, const float3 b);
81 ccl_device_inline float3 safe_divide_float3_float(const float3 a, const float b);
82 ccl_device_inline float3 interp(float3 a, float3 b, float t);
83 ccl_device_inline float3 sqr3(float3 a);
84
85 ccl_device_inline bool is_zero(const float3 a);
86 ccl_device_inline float reduce_add(const float3 a);
87 ccl_device_inline float average(const float3 a);
88 ccl_device_inline bool isequal_float3(const float3 a, const float3 b);
89
90 /*******************************************************************************
91 * Definition.
92 */
93
94 #ifndef __KERNEL_OPENCL__
95 ccl_device_inline float3 operator-(const float3 &a)
96 {
97 # ifdef __KERNEL_SSE__
98 return float3(_mm_xor_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x80000000))));
99 # else
100 return make_float3(-a.x, -a.y, -a.z);
101 # endif
102 }
103
104 ccl_device_inline float3 operator*(const float3 &a, const float3 &b)
105 {
106 # ifdef __KERNEL_SSE__
107 return float3(_mm_mul_ps(a.m128, b.m128));
108 # else
109 return make_float3(a.x * b.x, a.y * b.y, a.z * b.z);
110 # endif
111 }
112
113 ccl_device_inline float3 operator*(const float3 &a, const float f)
114 {
115 # ifdef __KERNEL_SSE__
116 return float3(_mm_mul_ps(a.m128, _mm_set1_ps(f)));
117 # else
118 return make_float3(a.x * f, a.y * f, a.z * f);
119 # endif
120 }
121
122 ccl_device_inline float3 operator*(const float f, const float3 &a)
123 {
124 # if defined(__KERNEL_SSE__)
125 return float3(_mm_mul_ps(_mm_set1_ps(f), a.m128));
126 # else
127 return make_float3(a.x * f, a.y * f, a.z * f);
128 # endif
129 }
130
131 ccl_device_inline float3 operator/(const float f, const float3 &a)
132 {
133 # if defined(__KERNEL_SSE__)
134 return float3(_mm_div_ps(_mm_set1_ps(f), a.m128));
135 # else
136 return make_float3(f / a.x, f / a.y, f / a.z);
137 # endif
138 }
139
140 ccl_device_inline float3 operator/(const float3 &a, const float f)
141 {
142 float invf = 1.0f / f;
143 return a * invf;
144 }
145
146 ccl_device_inline float3 operator/(const float3 &a, const float3 &b)
147 {
148 # if defined(__KERNEL_SSE__)
149 return float3(_mm_div_ps(a.m128, b.m128));
150 # else
151 return make_float3(a.x / b.x, a.y / b.y, a.z / b.z);
152 # endif
153 }
154
155 ccl_device_inline float3 operator+(const float3 &a, const float f)
156 {
157 return a + make_float3(f, f, f);
158 }
159
160 ccl_device_inline float3 operator+(const float3 &a, const float3 &b)
161 {
162 # ifdef __KERNEL_SSE__
163 return float3(_mm_add_ps(a.m128, b.m128));
164 # else
165 return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
166 # endif
167 }
168
169 ccl_device_inline float3 operator-(const float3 &a, const float f)
170 {
171 return a - make_float3(f, f, f);
172 }
173
174 ccl_device_inline float3 operator-(const float3 &a, const float3 &b)
175 {
176 # ifdef __KERNEL_SSE__
177 return float3(_mm_sub_ps(a.m128, b.m128));
178 # else
179 return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
180 # endif
181 }
182
183 ccl_device_inline float3 operator+=(float3 &a, const float3 &b)
184 {
185 return a = a + b;
186 }
187
188 ccl_device_inline float3 operator-=(float3 &a, const float3 &b)
189 {
190 return a = a - b;
191 }
192
193 ccl_device_inline float3 operator*=(float3 &a, const float3 &b)
194 {
195 return a = a * b;
196 }
197
198 ccl_device_inline float3 operator*=(float3 &a, float f)
199 {
200 return a = a * f;
201 }
202
203 ccl_device_inline float3 operator/=(float3 &a, const float3 &b)
204 {
205 return a = a / b;
206 }
207
208 ccl_device_inline float3 operator/=(float3 &a, float f)
209 {
210 float invf = 1.0f / f;
211 return a = a * invf;
212 }
213
214 ccl_device_inline bool operator==(const float3 &a, const float3 &b)
215 {
216 # ifdef __KERNEL_SSE__
217 return (_mm_movemask_ps(_mm_cmpeq_ps(a.m128, b.m128)) & 7) == 7;
218 # else
219 return (a.x == b.x && a.y == b.y && a.z == b.z);
220 # endif
221 }
222
223 ccl_device_inline bool operator!=(const float3 &a, const float3 &b)
224 {
225 return !(a == b);
226 }
227
distance(const float3 & a,const float3 & b)228 ccl_device_inline float distance(const float3 &a, const float3 &b)
229 {
230 return len(a - b);
231 }
232
dot(const float3 & a,const float3 & b)233 ccl_device_inline float dot(const float3 &a, const float3 &b)
234 {
235 # if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
236 return _mm_cvtss_f32(_mm_dp_ps(a, b, 0x7F));
237 # else
238 return a.x * b.x + a.y * b.y + a.z * b.z;
239 # endif
240 }
241
dot_xy(const float3 & a,const float3 & b)242 ccl_device_inline float dot_xy(const float3 &a, const float3 &b)
243 {
244 # if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
245 return _mm_cvtss_f32(_mm_hadd_ps(_mm_mul_ps(a, b), b));
246 # else
247 return a.x * b.x + a.y * b.y;
248 # endif
249 }
250
cross(const float3 & a,const float3 & b)251 ccl_device_inline float3 cross(const float3 &a, const float3 &b)
252 {
253 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);
254 return r;
255 }
256
normalize(const float3 & a)257 ccl_device_inline float3 normalize(const float3 &a)
258 {
259 # if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
260 __m128 norm = _mm_sqrt_ps(_mm_dp_ps(a.m128, a.m128, 0x7F));
261 return float3(_mm_div_ps(a.m128, norm));
262 # else
263 return a / len(a);
264 # endif
265 }
266
min(const float3 & a,const float3 & b)267 ccl_device_inline float3 min(const float3 &a, const float3 &b)
268 {
269 # ifdef __KERNEL_SSE__
270 return float3(_mm_min_ps(a.m128, b.m128));
271 # else
272 return make_float3(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z));
273 # endif
274 }
275
max(const float3 & a,const float3 & b)276 ccl_device_inline float3 max(const float3 &a, const float3 &b)
277 {
278 # ifdef __KERNEL_SSE__
279 return float3(_mm_max_ps(a.m128, b.m128));
280 # else
281 return make_float3(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z));
282 # endif
283 }
284
clamp(const float3 & a,const float3 & mn,const float3 & mx)285 ccl_device_inline float3 clamp(const float3 &a, const float3 &mn, const float3 &mx)
286 {
287 return min(max(a, mn), mx);
288 }
289
fabs(const float3 & a)290 ccl_device_inline float3 fabs(const float3 &a)
291 {
292 # ifdef __KERNEL_SSE__
293 __m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff));
294 return float3(_mm_and_ps(a.m128, mask));
295 # else
296 return make_float3(fabsf(a.x), fabsf(a.y), fabsf(a.z));
297 # endif
298 }
299
sqrt(const float3 & a)300 ccl_device_inline float3 sqrt(const float3 &a)
301 {
302 # ifdef __KERNEL_SSE__
303 return float3(_mm_sqrt_ps(a));
304 # else
305 return make_float3(sqrtf(a.x), sqrtf(a.y), sqrtf(a.z));
306 # endif
307 }
308
floor(const float3 & a)309 ccl_device_inline float3 floor(const float3 &a)
310 {
311 # ifdef __KERNEL_SSE__
312 return float3(_mm_floor_ps(a));
313 # else
314 return make_float3(floorf(a.x), floorf(a.y), floorf(a.z));
315 # endif
316 }
317
ceil(const float3 & a)318 ccl_device_inline float3 ceil(const float3 &a)
319 {
320 # ifdef __KERNEL_SSE__
321 return float3(_mm_ceil_ps(a));
322 # else
323 return make_float3(ceilf(a.x), ceilf(a.y), ceilf(a.z));
324 # endif
325 }
326
mix(const float3 & a,const float3 & b,float t)327 ccl_device_inline float3 mix(const float3 &a, const float3 &b, float t)
328 {
329 return a + t * (b - a);
330 }
331
rcp(const float3 & a)332 ccl_device_inline float3 rcp(const float3 &a)
333 {
334 # ifdef __KERNEL_SSE__
335 /* Don't use _mm_rcp_ps due to poor precision. */
336 return float3(_mm_div_ps(_mm_set_ps1(1.0f), a.m128));
337 # else
338 return make_float3(1.0f / a.x, 1.0f / a.y, 1.0f / a.z);
339 # endif
340 }
341 #endif /* !__KERNEL_OPENCL__ */
342
min3(float3 a)343 ccl_device_inline float min3(float3 a)
344 {
345 return min(min(a.x, a.y), a.z);
346 }
347
max3(float3 a)348 ccl_device_inline float max3(float3 a)
349 {
350 return max(max(a.x, a.y), a.z);
351 }
352
len(const float3 a)353 ccl_device_inline float len(const float3 a)
354 {
355 #if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
356 return _mm_cvtss_f32(_mm_sqrt_ss(_mm_dp_ps(a.m128, a.m128, 0x7F)));
357 #else
358 return sqrtf(dot(a, a));
359 #endif
360 }
361
len_squared(const float3 a)362 ccl_device_inline float len_squared(const float3 a)
363 {
364 return dot(a, a);
365 }
366
reflect(const float3 incident,const float3 normal)367 ccl_device_inline float3 reflect(const float3 incident, const float3 normal)
368 {
369 float3 unit_normal = normalize(normal);
370 return incident - 2.0f * unit_normal * dot(incident, unit_normal);
371 }
372
project(const float3 v,const float3 v_proj)373 ccl_device_inline float3 project(const float3 v, const float3 v_proj)
374 {
375 float len_squared = dot(v_proj, v_proj);
376 return (len_squared != 0.0f) ? (dot(v, v_proj) / len_squared) * v_proj :
377 make_float3(0.0f, 0.0f, 0.0f);
378 }
379
saturate3(float3 a)380 ccl_device_inline float3 saturate3(float3 a)
381 {
382 return make_float3(saturate(a.x), saturate(a.y), saturate(a.z));
383 }
384
normalize_len(const float3 a,float * t)385 ccl_device_inline float3 normalize_len(const float3 a, float *t)
386 {
387 *t = len(a);
388 float x = 1.0f / *t;
389 return a * x;
390 }
391
safe_normalize(const float3 a)392 ccl_device_inline float3 safe_normalize(const float3 a)
393 {
394 float t = len(a);
395 return (t != 0.0f) ? a * (1.0f / t) : a;
396 }
397
safe_normalize_len(const float3 a,float * t)398 ccl_device_inline float3 safe_normalize_len(const float3 a, float *t)
399 {
400 *t = len(a);
401 return (*t != 0.0f) ? a / (*t) : a;
402 }
403
safe_divide_float3_float3(const float3 a,const float3 b)404 ccl_device_inline float3 safe_divide_float3_float3(const float3 a, const float3 b)
405 {
406 return make_float3((b.x != 0.0f) ? a.x / b.x : 0.0f,
407 (b.y != 0.0f) ? a.y / b.y : 0.0f,
408 (b.z != 0.0f) ? a.z / b.z : 0.0f);
409 }
410
safe_divide_float3_float(const float3 a,const float b)411 ccl_device_inline float3 safe_divide_float3_float(const float3 a, const float b)
412 {
413 return (b != 0.0f) ? a / b : make_float3(0.0f, 0.0f, 0.0f);
414 }
415
interp(float3 a,float3 b,float t)416 ccl_device_inline float3 interp(float3 a, float3 b, float t)
417 {
418 return a + t * (b - a);
419 }
420
sqr3(float3 a)421 ccl_device_inline float3 sqr3(float3 a)
422 {
423 return a * a;
424 }
425
is_zero(const float3 a)426 ccl_device_inline bool is_zero(const float3 a)
427 {
428 #ifdef __KERNEL_SSE__
429 return a == make_float3(0.0f);
430 #else
431 return (a.x == 0.0f && a.y == 0.0f && a.z == 0.0f);
432 #endif
433 }
434
reduce_add(const float3 a)435 ccl_device_inline float reduce_add(const float3 a)
436 {
437 return (a.x + a.y + a.z);
438 }
439
average(const float3 a)440 ccl_device_inline float average(const float3 a)
441 {
442 return reduce_add(a) * (1.0f / 3.0f);
443 }
444
isequal_float3(const float3 a,const float3 b)445 ccl_device_inline bool isequal_float3(const float3 a, const float3 b)
446 {
447 #ifdef __KERNEL_OPENCL__
448 return all(a == b);
449 #else
450 return a == b;
451 #endif
452 }
453
pow3(float3 v,float e)454 ccl_device_inline float3 pow3(float3 v, float e)
455 {
456 return make_float3(powf(v.x, e), powf(v.y, e), powf(v.z, e));
457 }
458
exp3(float3 v)459 ccl_device_inline float3 exp3(float3 v)
460 {
461 return make_float3(expf(v.x), expf(v.y), expf(v.z));
462 }
463
log3(float3 v)464 ccl_device_inline float3 log3(float3 v)
465 {
466 return make_float3(logf(v.x), logf(v.y), logf(v.z));
467 }
468
quick_floor_to_int3(const float3 a)469 ccl_device_inline int3 quick_floor_to_int3(const float3 a)
470 {
471 #ifdef __KERNEL_SSE__
472 int3 b = int3(_mm_cvttps_epi32(a.m128));
473 int3 isneg = int3(_mm_castps_si128(_mm_cmplt_ps(a.m128, _mm_set_ps1(0.0f))));
474 /* Unsaturated add 0xffffffff is the same as subtract -1. */
475 return b + isneg;
476 #else
477 return make_int3(quick_floor_to_int(a.x), quick_floor_to_int(a.y), quick_floor_to_int(a.z));
478 #endif
479 }
480
isfinite3_safe(float3 v)481 ccl_device_inline bool isfinite3_safe(float3 v)
482 {
483 return isfinite_safe(v.x) && isfinite_safe(v.y) && isfinite_safe(v.z);
484 }
485
ensure_finite3(float3 v)486 ccl_device_inline float3 ensure_finite3(float3 v)
487 {
488 if (!isfinite_safe(v.x))
489 v.x = 0.0f;
490 if (!isfinite_safe(v.y))
491 v.y = 0.0f;
492 if (!isfinite_safe(v.z))
493 v.z = 0.0f;
494 return v;
495 }
496
497 CCL_NAMESPACE_END
498
499 #endif /* __UTIL_MATH_FLOAT3_H__ */
500