Merge branch 'master' into blender2.8
[blender.git] / intern / cycles / util / util_ssef.h
1 /*
2  * Copyright 2011-2013 Intel Corporation
3  * Modifications Copyright 2014, Blender Foundation.
4  *
5  * Licensed under the Apache License, Version 2.0(the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #ifndef __UTIL_SSEF_H__
19 #define __UTIL_SSEF_H__
20
21 CCL_NAMESPACE_BEGIN
22
23 #ifdef __KERNEL_SSE2__
24
25 struct sseb;
26 struct ssef;
27
28 /*! 4-wide SSE float type. */
29 struct ssef
30 {
31         typedef sseb Mask;                    // mask type
32         typedef ssei Int;                     // int type
33         typedef ssef Float;                   // float type
34         
35         enum   { size = 4 };  // number of SIMD elements
36         union { __m128 m128; float f[4]; int i[4]; }; // data
37
38         ////////////////////////////////////////////////////////////////////////////////
39         /// Constructors, Assignment & Cast Operators
40         ////////////////////////////////////////////////////////////////////////////////
41         
42         __forceinline ssef          () {}
43         __forceinline ssef          (const ssef& other) { m128 = other.m128; }
44         __forceinline ssef& operator=(const ssef& other) { m128 = other.m128; return *this; }
45
46         __forceinline ssef(const __m128 a) : m128(a) {}
47         __forceinline operator const __m128&(void) const { return m128; }
48         __forceinline operator       __m128&(void)       { return m128; }
49
50         __forceinline ssef          (float a) : m128(_mm_set1_ps(a)) {}
51         __forceinline ssef          (float a, float b, float c, float d) : m128(_mm_setr_ps(a, b, c, d)) {}
52
53         __forceinline explicit ssef(const __m128i a) : m128(_mm_cvtepi32_ps(a)) {}
54
55         ////////////////////////////////////////////////////////////////////////////////
56         /// Loads and Stores
57         ////////////////////////////////////////////////////////////////////////////////
58
59 #if defined(__KERNEL_AVX__)
60         static __forceinline ssef broadcast(const void* const a) { return _mm_broadcast_ss((float*)a); }
61 #else
62         static __forceinline ssef broadcast(const void* const a) { return _mm_set1_ps(*(float*)a); }
63 #endif
64
65         ////////////////////////////////////////////////////////////////////////////////
66         /// Array Access
67         ////////////////////////////////////////////////////////////////////////////////
68
69         __forceinline const float& operator [](const size_t i) const { assert(i < 4); return f[i]; }
70         __forceinline       float& operator [](const size_t i)       { assert(i < 4); return f[i]; }
71 };
72
73
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Unary Operators
76 ////////////////////////////////////////////////////////////////////////////////
77
78 __forceinline const ssef cast     (const __m128i& a) { return _mm_castsi128_ps(a); }
79 __forceinline const ssef operator +(const ssef& a) { return a; }
80 __forceinline const ssef operator -(const ssef& a) { return _mm_xor_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x80000000))); }
81 __forceinline const ssef abs      (const ssef& a) { return _mm_and_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff))); }
82 #if defined(__KERNEL_SSE41__)
83 __forceinline const ssef sign     (const ssef& a) { return _mm_blendv_ps(ssef(1.0f), -ssef(1.0f), _mm_cmplt_ps(a,ssef(0.0f))); }
84 #endif
85 __forceinline const ssef signmsk  (const ssef& a) { return _mm_and_ps(a.m128,_mm_castsi128_ps(_mm_set1_epi32(0x80000000))); }
86
87 __forceinline const ssef rcp (const ssef& a) {
88         const ssef r = _mm_rcp_ps(a.m128);
89         return _mm_sub_ps(_mm_add_ps(r, r), _mm_mul_ps(_mm_mul_ps(r, r), a));
90 }
91 __forceinline const ssef sqr (const ssef& a) { return _mm_mul_ps(a,a); }
92 __forceinline const ssef mm_sqrt(const ssef& a) { return _mm_sqrt_ps(a.m128); }
93 __forceinline const ssef rsqrt(const ssef& a) {
94         const ssef r = _mm_rsqrt_ps(a.m128);
95         return _mm_add_ps(_mm_mul_ps(_mm_set_ps(1.5f, 1.5f, 1.5f, 1.5f), r),
96                                           _mm_mul_ps(_mm_mul_ps(_mm_mul_ps(a, _mm_set_ps(-0.5f, -0.5f, -0.5f, -0.5f)), r), _mm_mul_ps(r, r)));
97 }
98
99 ////////////////////////////////////////////////////////////////////////////////
100 /// Binary Operators
101 ////////////////////////////////////////////////////////////////////////////////
102
103 __forceinline const ssef operator +(const ssef& a, const ssef& b) { return _mm_add_ps(a.m128, b.m128); }
104 __forceinline const ssef operator +(const ssef& a, const float& b) { return a + ssef(b); }
105 __forceinline const ssef operator +(const float& a, const ssef& b) { return ssef(a) + b; }
106
107 __forceinline const ssef operator -(const ssef& a, const ssef& b) { return _mm_sub_ps(a.m128, b.m128); }
108 __forceinline const ssef operator -(const ssef& a, const float& b) { return a - ssef(b); }
109 __forceinline const ssef operator -(const float& a, const ssef& b) { return ssef(a) - b; }
110
111 __forceinline const ssef operator *(const ssef& a, const ssef& b) { return _mm_mul_ps(a.m128, b.m128); }
112 __forceinline const ssef operator *(const ssef& a, const float& b) { return a * ssef(b); }
113 __forceinline const ssef operator *(const float& a, const ssef& b) { return ssef(a) * b; }
114
115 __forceinline const ssef operator /(const ssef& a, const ssef& b) { return _mm_div_ps(a.m128,b.m128); }
116 __forceinline const ssef operator /(const ssef& a, const float& b) { return a/ssef(b); }
117 __forceinline const ssef operator /(const float& a, const ssef& b) { return ssef(a)/b; }
118
119 __forceinline const ssef operator^(const ssef& a, const ssef& b) { return _mm_xor_ps(a.m128,b.m128); }
120 __forceinline const ssef operator^(const ssef& a, const ssei& b) { return _mm_xor_ps(a.m128,_mm_castsi128_ps(b.m128)); }
121
122 __forceinline const ssef operator&(const ssef& a, const ssef& b) { return _mm_and_ps(a.m128,b.m128); }
123 __forceinline const ssef operator&(const ssef& a, const ssei& b) { return _mm_and_ps(a.m128,_mm_castsi128_ps(b.m128)); }
124
125 __forceinline const ssef operator|(const ssef& a, const ssef& b) { return _mm_or_ps(a.m128,b.m128); }
126 __forceinline const ssef operator|(const ssef& a, const ssei& b) { return _mm_or_ps(a.m128,_mm_castsi128_ps(b.m128)); }
127
128 __forceinline const ssef andnot(const ssef& a, const ssef& b) { return _mm_andnot_ps(a.m128,b.m128); }
129
130 __forceinline const ssef min(const ssef& a, const ssef& b) { return _mm_min_ps(a.m128,b.m128); }
131 __forceinline const ssef min(const ssef& a, const float& b) { return _mm_min_ps(a.m128,ssef(b)); }
132 __forceinline const ssef min(const float& a, const ssef& b) { return _mm_min_ps(ssef(a),b.m128); }
133
134 __forceinline const ssef max(const ssef& a, const ssef& b) { return _mm_max_ps(a.m128,b.m128); }
135 __forceinline const ssef max(const ssef& a, const float& b) { return _mm_max_ps(a.m128,ssef(b)); }
136 __forceinline const ssef max(const float& a, const ssef& b) { return _mm_max_ps(ssef(a),b.m128); }
137
138 #if defined(__KERNEL_SSE41__)
139 __forceinline ssef mini(const ssef& a, const ssef& b) {
140         const ssei ai = _mm_castps_si128(a);
141         const ssei bi = _mm_castps_si128(b);
142         const ssei ci = _mm_min_epi32(ai,bi);
143         return _mm_castsi128_ps(ci);
144 }
145 #endif
146         
147 #if defined(__KERNEL_SSE41__)
148 __forceinline ssef maxi(const ssef& a, const ssef& b) {
149         const ssei ai = _mm_castps_si128(a);
150         const ssei bi = _mm_castps_si128(b);
151         const ssei ci = _mm_max_epi32(ai,bi);
152         return _mm_castsi128_ps(ci);
153 }
154 #endif
155
156 ////////////////////////////////////////////////////////////////////////////////
157 /// Ternary Operators
158 ////////////////////////////////////////////////////////////////////////////////
159
160 #if defined(__KERNEL_AVX2__)
161 __forceinline const ssef madd (const ssef& a, const ssef& b, const ssef& c) { return _mm_fmadd_ps(a,b,c); }
162 __forceinline const ssef msub (const ssef& a, const ssef& b, const ssef& c) { return _mm_fmsub_ps(a,b,c); }
163 __forceinline const ssef nmadd(const ssef& a, const ssef& b, const ssef& c) { return _mm_fnmadd_ps(a,b,c); }
164 __forceinline const ssef nmsub(const ssef& a, const ssef& b, const ssef& c) { return _mm_fnmsub_ps(a,b,c); }
165 #else
166 __forceinline const ssef madd (const ssef& a, const ssef& b, const ssef& c) { return a*b+c; }
167 __forceinline const ssef msub (const ssef& a, const ssef& b, const ssef& c) { return a*b-c; }
168 __forceinline const ssef nmadd(const ssef& a, const ssef& b, const ssef& c) { return c-a*b;}
169 __forceinline const ssef nmsub(const ssef& a, const ssef& b, const ssef& c) { return -a*b-c; }
170 #endif
171
172 ////////////////////////////////////////////////////////////////////////////////
173 /// Assignment Operators
174 ////////////////////////////////////////////////////////////////////////////////
175
176 __forceinline ssef& operator +=(ssef& a, const ssef& b) { return a = a + b; }
177 __forceinline ssef& operator +=(ssef& a, const float& b) { return a = a + b; }
178
179 __forceinline ssef& operator -=(ssef& a, const ssef& b) { return a = a - b; }
180 __forceinline ssef& operator -=(ssef& a, const float& b) { return a = a - b; }
181
182 __forceinline ssef& operator *=(ssef& a, const ssef& b) { return a = a * b; }
183 __forceinline ssef& operator *=(ssef& a, const float& b) { return a = a * b; }
184
185 __forceinline ssef& operator /=(ssef& a, const ssef& b) { return a = a / b; }
186 __forceinline ssef& operator /=(ssef& a, const float& b) { return a = a / b; }
187
188 ////////////////////////////////////////////////////////////////////////////////
189 /// Comparison Operators + Select
190 ////////////////////////////////////////////////////////////////////////////////
191
192 __forceinline const sseb operator ==(const ssef& a, const ssef& b) { return _mm_cmpeq_ps(a.m128, b.m128); }
193 __forceinline const sseb operator ==(const ssef& a, const float& b) { return a == ssef(b); }
194 __forceinline const sseb operator ==(const float& a, const ssef& b) { return ssef(a) == b; }
195
196 __forceinline const sseb operator !=(const ssef& a, const ssef& b) { return _mm_cmpneq_ps(a.m128, b.m128); }
197 __forceinline const sseb operator !=(const ssef& a, const float& b) { return a != ssef(b); }
198 __forceinline const sseb operator !=(const float& a, const ssef& b) { return ssef(a) != b; }
199
200 __forceinline const sseb operator <(const ssef& a, const ssef& b) { return _mm_cmplt_ps(a.m128, b.m128); }
201 __forceinline const sseb operator <(const ssef& a, const float& b) { return a <  ssef(b); }
202 __forceinline const sseb operator <(const float& a, const ssef& b) { return ssef(a) <  b; }
203
204 __forceinline const sseb operator >=(const ssef& a, const ssef& b) { return _mm_cmpnlt_ps(a.m128, b.m128); }
205 __forceinline const sseb operator >=(const ssef& a, const float& b) { return a >= ssef(b); }
206 __forceinline const sseb operator >=(const float& a, const ssef& b) { return ssef(a) >= b; }
207
208 __forceinline const sseb operator >(const ssef& a, const ssef& b) { return _mm_cmpnle_ps(a.m128, b.m128); }
209 __forceinline const sseb operator >(const ssef& a, const float& b) { return a >  ssef(b); }
210 __forceinline const sseb operator >(const float& a, const ssef& b) { return ssef(a) >  b; }
211
212 __forceinline const sseb operator <=(const ssef& a, const ssef& b) { return _mm_cmple_ps(a.m128, b.m128); }
213 __forceinline const sseb operator <=(const ssef& a, const float& b) { return a <= ssef(b); }
214 __forceinline const sseb operator <=(const float& a, const ssef& b) { return ssef(a) <= b; }
215
216 __forceinline const ssef select(const sseb& m, const ssef& t, const ssef& f) {
217 #ifdef __KERNEL_SSE41__
218         return _mm_blendv_ps(f, t, m);
219 #else
220         return _mm_or_ps(_mm_and_ps(m, t), _mm_andnot_ps(m, f));
221 #endif
222 }
223
224 __forceinline const ssef select(const ssef& m, const ssef& t, const ssef& f) {
225 #ifdef __KERNEL_SSE41__
226         return _mm_blendv_ps(f, t, m);
227 #else
228         return _mm_or_ps(_mm_and_ps(m, t), _mm_andnot_ps(m, f));
229 #endif
230 }
231
232 __forceinline const ssef select(const int mask, const ssef& t, const ssef& f) { 
233 #if defined(__KERNEL_SSE41__) && ((!defined(__clang__) && !defined(_MSC_VER)) || defined(__INTEL_COMPILER))
234         return _mm_blend_ps(f, t, mask);
235 #else
236         return select(sseb(mask),t,f);
237 #endif
238 }
239
240 ////////////////////////////////////////////////////////////////////////////////
241 /// Rounding Functions
242 ////////////////////////////////////////////////////////////////////////////////
243
244 #if defined(__KERNEL_SSE41__)
245 __forceinline const ssef round_even(const ssef& a) { return _mm_round_ps(a, _MM_FROUND_TO_NEAREST_INT); }
246 __forceinline const ssef round_down(const ssef& a) { return _mm_round_ps(a, _MM_FROUND_TO_NEG_INF   ); }
247 __forceinline const ssef round_up (const ssef& a) { return _mm_round_ps(a, _MM_FROUND_TO_POS_INF   ); }
248 __forceinline const ssef round_zero(const ssef& a) { return _mm_round_ps(a, _MM_FROUND_TO_ZERO      ); }
249 __forceinline const ssef floor    (const ssef& a) { return _mm_round_ps(a, _MM_FROUND_TO_NEG_INF   ); }
250 __forceinline const ssef ceil     (const ssef& a) { return _mm_round_ps(a, _MM_FROUND_TO_POS_INF   ); }
251 #endif
252
253 __forceinline ssei truncatei(const ssef& a) {
254         return _mm_cvttps_epi32(a.m128);
255 }
256
257 __forceinline ssei floori(const ssef& a) {
258 #if defined(__KERNEL_SSE41__)
259         return ssei(floor(a));
260 #else
261         return ssei(a-ssef(0.5f));
262 #endif
263 }
264
265 ////////////////////////////////////////////////////////////////////////////////
266 /// Movement/Shifting/Shuffling Functions
267 ////////////////////////////////////////////////////////////////////////////////
268
269 __forceinline ssef unpacklo(const ssef& a, const ssef& b) { return _mm_unpacklo_ps(a.m128, b.m128); }
270 __forceinline ssef unpackhi(const ssef& a, const ssef& b) { return _mm_unpackhi_ps(a.m128, b.m128); }
271
272 template<size_t i0, size_t i1, size_t i2, size_t i3> __forceinline const ssef shuffle(const ssef& b) {
273         return _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(b), _MM_SHUFFLE(i3, i2, i1, i0)));
274 }
275
276 template<> __forceinline const ssef shuffle<0, 1, 0, 1>(const ssef& a) {
277         return _mm_movelh_ps(a, a);
278 }
279
280 template<> __forceinline const ssef shuffle<2, 3, 2, 3>(const ssef& a) {
281         return _mm_movehl_ps(a, a);
282 }
283
284 template<size_t i0, size_t i1, size_t i2, size_t i3> __forceinline const ssef shuffle(const ssef& a, const ssef& b) {
285         return _mm_shuffle_ps(a, b, _MM_SHUFFLE(i3, i2, i1, i0));
286 }
287
288 template<size_t i0> __forceinline const ssef shuffle(const ssef& a, const ssef& b) {
289         return _mm_shuffle_ps(a, b, _MM_SHUFFLE(i0, i0, i0, i0));
290 }
291
292 template<> __forceinline const ssef shuffle<0, 1, 0, 1>(const ssef& a, const ssef& b) {
293         return _mm_movelh_ps(a, b);
294 }
295
296 template<> __forceinline const ssef shuffle<2, 3, 2, 3>(const ssef& a, const ssef& b) {
297         return _mm_movehl_ps(b, a);
298 }
299
300 #if defined(__KERNEL_SSSE3__)
301 __forceinline const ssef shuffle8(const ssef& a, const ssei& shuf) { 
302         return _mm_castsi128_ps(_mm_shuffle_epi8(_mm_castps_si128(a), shuf)); 
303 }
304 #endif
305
306 #if defined(__KERNEL_SSE3__)
307 template<> __forceinline const ssef shuffle<0, 0, 2, 2>(const ssef& b) { return _mm_moveldup_ps(b); }
308 template<> __forceinline const ssef shuffle<1, 1, 3, 3>(const ssef& b) { return _mm_movehdup_ps(b); }
309 #endif
310
311 template<size_t i0> __forceinline const ssef shuffle(const ssef& b) {
312         return shuffle<i0,i0,i0,i0>(b);
313 }
314
315 #if defined(__KERNEL_AVX__)
316 __forceinline const ssef shuffle(const ssef& a, const ssei& shuf) {
317         return _mm_permutevar_ps(a, shuf);
318 }
319 #endif
320
321 template<size_t i> __forceinline float extract   (const ssef& a) { return _mm_cvtss_f32(shuffle<i,i,i,i>(a)); }
322 template<>         __forceinline float extract<0>(const ssef& a) { return _mm_cvtss_f32(a); }
323
324 #if defined(__KERNEL_SSE41__)
325 template<size_t dst, size_t src, size_t clr> __forceinline const ssef insert(const ssef& a, const ssef& b) { return _mm_insert_ps(a, b,(dst << 4) |(src << 6) | clr); }
326 template<size_t dst, size_t src> __forceinline const ssef insert(const ssef& a, const ssef& b) { return insert<dst, src, 0>(a, b); }
327 template<size_t dst>             __forceinline const ssef insert(const ssef& a, const float b) { return insert<dst,      0>(a, _mm_set_ss(b)); }
328 #else
329 template<size_t dst>             __forceinline const ssef insert(const ssef& a, const float b) { ssef c = a; c[dst] = b; return c; }
330 #endif
331
332 ////////////////////////////////////////////////////////////////////////////////
333 /// Transpose
334 ////////////////////////////////////////////////////////////////////////////////
335
336 __forceinline void transpose(const ssef& r0, const ssef& r1, const ssef& r2, const ssef& r3, ssef& c0, ssef& c1, ssef& c2, ssef& c3) 
337 {
338         ssef l02 = unpacklo(r0,r2);
339         ssef h02 = unpackhi(r0,r2);
340         ssef l13 = unpacklo(r1,r3);
341         ssef h13 = unpackhi(r1,r3);
342         c0 = unpacklo(l02,l13);
343         c1 = unpackhi(l02,l13);
344         c2 = unpacklo(h02,h13);
345         c3 = unpackhi(h02,h13);
346 }
347
348 __forceinline void transpose(const ssef& r0, const ssef& r1, const ssef& r2, const ssef& r3, ssef& c0, ssef& c1, ssef& c2) 
349 {
350         ssef l02 = unpacklo(r0,r2);
351         ssef h02 = unpackhi(r0,r2);
352         ssef l13 = unpacklo(r1,r3);
353         ssef h13 = unpackhi(r1,r3);
354         c0 = unpacklo(l02,l13);
355         c1 = unpackhi(l02,l13);
356         c2 = unpacklo(h02,h13);
357 }
358
359 ////////////////////////////////////////////////////////////////////////////////
360 /// Reductions
361 ////////////////////////////////////////////////////////////////////////////////
362
363 __forceinline const ssef vreduce_min(const ssef& v) { ssef h = min(shuffle<1,0,3,2>(v),v); return min(shuffle<2,3,0,1>(h),h); }
364 __forceinline const ssef vreduce_max(const ssef& v) { ssef h = max(shuffle<1,0,3,2>(v),v); return max(shuffle<2,3,0,1>(h),h); }
365 __forceinline const ssef vreduce_add(const ssef& v) { ssef h = shuffle<1,0,3,2>(v)   + v ; return shuffle<2,3,0,1>(h)   + h ; }
366
367 __forceinline float reduce_min(const ssef& v) { return _mm_cvtss_f32(vreduce_min(v)); }
368 __forceinline float reduce_max(const ssef& v) { return _mm_cvtss_f32(vreduce_max(v)); }
369 __forceinline float reduce_add(const ssef& v) { return _mm_cvtss_f32(vreduce_add(v)); }
370
371 __forceinline size_t select_min(const ssef& v) { return __bsf(movemask(v == vreduce_min(v))); }
372 __forceinline size_t select_max(const ssef& v) { return __bsf(movemask(v == vreduce_max(v))); }
373
374 __forceinline size_t select_min(const sseb& valid, const ssef& v) { const ssef a = select(valid,v,ssef(pos_inf)); return __bsf(movemask(valid &(a == vreduce_min(a)))); }
375 __forceinline size_t select_max(const sseb& valid, const ssef& v) { const ssef a = select(valid,v,ssef(neg_inf)); return __bsf(movemask(valid &(a == vreduce_max(a)))); }
376
377 __forceinline size_t movemask( const ssef& a ) { return _mm_movemask_ps(a); }
378
379 ////////////////////////////////////////////////////////////////////////////////
380 /// Memory load and store operations
381 ////////////////////////////////////////////////////////////////////////////////
382
383 __forceinline ssef load4f(const float4& a) {
384 #ifdef __KERNEL_WITH_SSE_ALIGN__
385         return _mm_load_ps(&a.x); 
386 #else
387         return _mm_loadu_ps(&a.x); 
388 #endif
389 }
390
391 __forceinline ssef load4f(const float3& a) {
392 #ifdef __KERNEL_WITH_SSE_ALIGN__
393         return _mm_load_ps(&a.x); 
394 #else
395         return _mm_loadu_ps(&a.x); 
396 #endif
397 }
398
399 __forceinline ssef load4f(const void* const a) {
400         return _mm_load_ps((float*)a); 
401 }
402
403 __forceinline ssef load1f_first(const float a) {
404         return _mm_set_ss(a);
405 }
406
407 __forceinline void store4f(void* ptr, const ssef& v) {
408         _mm_store_ps((float*)ptr,v);
409 }
410
411 __forceinline ssef loadu4f(const void* const a) {
412         return _mm_loadu_ps((float*)a); 
413 }
414
415 __forceinline void storeu4f(void* ptr, const ssef& v) {
416         _mm_storeu_ps((float*)ptr,v);
417 }
418
419 __forceinline void store4f(const sseb& mask, void* ptr, const ssef& f) { 
420 #if defined(__KERNEL_AVX__)
421         _mm_maskstore_ps((float*)ptr,(__m128i)mask,f);
422 #else
423         *(ssef*)ptr = select(mask,f,*(ssef*)ptr);
424 #endif
425 }
426
427 __forceinline ssef load4f_nt(void* ptr) {
428 #if defined(__KERNEL_SSE41__)
429         return _mm_castsi128_ps(_mm_stream_load_si128((__m128i*)ptr));
430 #else
431         return _mm_load_ps((float*)ptr); 
432 #endif
433 }
434
435 __forceinline void store4f_nt(void* ptr, const ssef& v) {
436 #if defined(__KERNEL_SSE41__)
437         _mm_stream_ps((float*)ptr,v);
438 #else
439         _mm_store_ps((float*)ptr,v);
440 #endif
441 }
442
443 ////////////////////////////////////////////////////////////////////////////////
444 /// Euclidian Space Operators
445 ////////////////////////////////////////////////////////////////////////////////
446
447 __forceinline float dot(const ssef& a, const ssef& b) {
448         return reduce_add(a*b);
449 }
450
451 /* calculate shuffled cross product, useful when order of components does not matter */
452 __forceinline ssef cross_zxy(const ssef& a, const ssef& b) 
453 {
454         const ssef a0 = a;
455         const ssef b0 = shuffle<1,2,0,3>(b);
456         const ssef a1 = shuffle<1,2,0,3>(a);
457         const ssef b1 = b;
458         return msub(a0,b0,a1*b1);
459 }
460
461 __forceinline ssef cross(const ssef& a, const ssef& b) 
462 {
463         return shuffle<1,2,0,3>(cross_zxy(a, b));
464 }
465
466 ccl_device_inline const ssef dot3_splat(const ssef& a, const ssef& b)
467 {
468 #ifdef __KERNEL_SSE41__
469         return _mm_dp_ps(a.m128, b.m128, 0x7f);
470 #else
471         ssef t = a * b;
472         return ssef(((float*)&t)[0] + ((float*)&t)[1] + ((float*)&t)[2]);
473 #endif
474 }
475
476 /* squared length taking only specified axes into account */
477 template<size_t X, size_t Y, size_t Z, size_t W>
478 ccl_device_inline float len_squared(const ssef& a)
479 {
480 #ifndef __KERNEL_SSE41__
481         float4& t = (float4 &)a;
482         return (X ? t.x * t.x : 0.0f) + (Y ? t.y * t.y : 0.0f) + (Z ? t.z * t.z : 0.0f) + (W ? t.w * t.w : 0.0f);
483 #else
484         return extract<0>(ssef(_mm_dp_ps(a.m128, a.m128, (X << 4) | (Y << 5) | (Z << 6) | (W << 7) | 0xf)));
485 #endif
486 }
487
488 ccl_device_inline float dot3(const ssef& a, const ssef& b)
489 {
490 #ifdef __KERNEL_SSE41__
491         return extract<0>(ssef(_mm_dp_ps(a.m128, b.m128, 0x7f)));
492 #else
493         ssef t = a * b;
494         return ((float*)&t)[0] + ((float*)&t)[1] + ((float*)&t)[2];
495 #endif
496 }
497
498 ccl_device_inline const ssef len3_squared_splat(const ssef& a)
499 {
500         return dot3_splat(a, a);
501 }
502
503 ccl_device_inline float len3_squared(const ssef& a)
504 {
505         return dot3(a, a);
506 }
507
508 ccl_device_inline float len3(const ssef& a)
509 {
510         return extract<0>(mm_sqrt(dot3_splat(a, a)));
511 }
512
513 /* SSE shuffle utility functions */
514
515 #ifdef __KERNEL_SSSE3__
516
517 /* faster version for SSSE3 */
518 typedef ssei shuffle_swap_t;
519
520 ccl_device_inline shuffle_swap_t shuffle_swap_identity(void)
521 {
522         return _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
523 }
524
525 ccl_device_inline shuffle_swap_t shuffle_swap_swap(void)
526 {
527         return _mm_set_epi8(7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
528 }
529
530 ccl_device_inline const ssef shuffle_swap(const ssef& a, const shuffle_swap_t& shuf)
531 {
532         return cast(_mm_shuffle_epi8(cast(a), shuf));
533 }
534
535 #else
536
537 /* somewhat slower version for SSE2 */
538 typedef int shuffle_swap_t;
539
540 ccl_device_inline shuffle_swap_t shuffle_swap_identity(void)
541 {
542         return 0;
543 }
544
545 ccl_device_inline shuffle_swap_t shuffle_swap_swap(void)
546 {
547         return 1;
548 }
549
550 ccl_device_inline const ssef shuffle_swap(const ssef& a, shuffle_swap_t shuf)
551 {
552         /* shuffle value must be a constant, so we need to branch */
553         if(shuf)
554                 return ssef(_mm_shuffle_ps(a.m128, a.m128, _MM_SHUFFLE(1, 0, 3, 2)));
555         else
556                 return ssef(_mm_shuffle_ps(a.m128, a.m128, _MM_SHUFFLE(3, 2, 1, 0)));
557 }
558
559 #endif
560
561 #ifdef __KERNEL_SSE41__
562
563 ccl_device_inline void gen_idirsplat_swap(const ssef &pn, const shuffle_swap_t &shuf_identity, const shuffle_swap_t &shuf_swap,
564                                           const float3& idir, ssef idirsplat[3], shuffle_swap_t shufflexyz[3])
565 {
566         const __m128 idirsplat_raw[] = { _mm_set_ps1(idir.x), _mm_set_ps1(idir.y), _mm_set_ps1(idir.z) };
567         idirsplat[0] = _mm_xor_ps(idirsplat_raw[0], pn);
568         idirsplat[1] = _mm_xor_ps(idirsplat_raw[1], pn);
569         idirsplat[2] = _mm_xor_ps(idirsplat_raw[2], pn);
570
571         const ssef signmask = cast(ssei(0x80000000));
572         const ssef shuf_identity_f = cast(shuf_identity);
573         const ssef shuf_swap_f = cast(shuf_swap);
574
575         shufflexyz[0] = _mm_castps_si128(_mm_blendv_ps(shuf_identity_f, shuf_swap_f, _mm_and_ps(idirsplat_raw[0], signmask)));
576         shufflexyz[1] = _mm_castps_si128(_mm_blendv_ps(shuf_identity_f, shuf_swap_f, _mm_and_ps(idirsplat_raw[1], signmask)));
577         shufflexyz[2] = _mm_castps_si128(_mm_blendv_ps(shuf_identity_f, shuf_swap_f, _mm_and_ps(idirsplat_raw[2], signmask)));
578 }
579
580 #else
581
582 ccl_device_inline void gen_idirsplat_swap(const ssef &pn, const shuffle_swap_t &shuf_identity, const shuffle_swap_t &shuf_swap,
583                                           const float3& idir, ssef idirsplat[3], shuffle_swap_t shufflexyz[3])
584 {
585         idirsplat[0] = ssef(idir.x) ^ pn;
586         idirsplat[1] = ssef(idir.y) ^ pn;
587         idirsplat[2] = ssef(idir.z) ^ pn;
588
589         shufflexyz[0] = (idir.x >= 0)? shuf_identity: shuf_swap;
590         shufflexyz[1] = (idir.y >= 0)? shuf_identity: shuf_swap;
591         shufflexyz[2] = (idir.z >= 0)? shuf_identity: shuf_swap;
592 }
593
594 #endif
595
596 ccl_device_inline const ssef uint32_to_float(const ssei &in)
597 {
598         ssei a = _mm_srli_epi32(in, 16);
599         ssei b = _mm_and_si128(in, _mm_set1_epi32(0x0000ffff));
600         ssei c = _mm_or_si128(a, _mm_set1_epi32(0x53000000));
601         ssef d = _mm_cvtepi32_ps(b);
602         ssef e = _mm_sub_ps(_mm_castsi128_ps(c), _mm_castsi128_ps(_mm_set1_epi32(0x53000000)));
603         return _mm_add_ps(e, d);
604 }
605
606 template<size_t S1, size_t S2, size_t S3, size_t S4>
607 ccl_device_inline const ssef set_sign_bit(const ssef &a)
608 {
609         return cast(cast(a) ^ ssei(S1 << 31, S2 << 31, S3 << 31, S4 << 31));
610 }
611
612 ////////////////////////////////////////////////////////////////////////////////
613 /// Debug Functions
614 ////////////////////////////////////////////////////////////////////////////////
615
616 ccl_device_inline void print_ssef(const char *label, const ssef &a)
617 {
618         printf("%s: %.8f %.8f %.8f %.8f\n",
619                label,
620                (double)a[0],
621                (double)a[1],
622                (double)a[2],
623                (double)a[3]);
624 }
625
626 #endif
627
628 CCL_NAMESPACE_END
629
630 #endif
631