0bc67f0618a4d1f498c061bb76b879bc06a325e3
[blender.git] / intern / cycles / util / util_types.h
1 /*
2  * Copyright 2011, Blender Foundation.
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
19 #ifndef __UTIL_TYPES_H__
20 #define __UTIL_TYPES_H__
21
22 #ifndef __KERNEL_OPENCL__
23
24 #include <stdlib.h>
25
26 #endif
27
28 /* Qualifiers for kernel code shared by CPU and GPU */
29
30 #ifndef __KERNEL_GPU__
31
32 #define __device static inline
33 #define __device_noinline static
34 #define __global
35 #define __local
36 #define __shared
37 #define __constant
38
39 #if defined(_WIN32) && !defined(FREE_WINDOWS)
40 #define __device_inline static __forceinline
41 #define __align(...) __declspec(align(__VA_ARGS__))
42 #define __may_alias
43 #else
44 #define __device_inline static inline __attribute__((always_inline))
45 #ifndef FREE_WINDOWS64
46 #define __forceinline inline __attribute__((always_inline))
47 #endif
48 #define __align(...) __attribute__((aligned(__VA_ARGS__)))
49 #define __may_alias __attribute__((__may_alias__))
50 #endif
51
52 #endif
53
54 /* Bitness */
55
56 #if defined(__ppc64__) || defined(__PPC64__) || defined(__x86_64__) || defined(__ia64__) || defined(_M_X64)
57 #define __KERNEL_64_BIT__
58 #endif
59
60 /* SIMD Types */
61
62 #ifndef __KERNEL_GPU__
63
64 /* not enabled, globally applying it just gives slowdown,
65  * but useful for testing. */
66 //#define __KERNEL_SSE__
67 #ifdef __KERNEL_SSE__
68
69 #include <xmmintrin.h> /* SSE 1 */
70 #include <emmintrin.h> /* SSE 2 */
71 #include <pmmintrin.h> /* SSE 3 */
72 #include <tmmintrin.h> /* SSE 3 */
73 #include <smmintrin.h> /* SSE 4 */
74
75 #define __KERNEL_SSE2__
76 #define __KERNEL_SSE3__
77 #define __KERNEL_SSE4__
78
79 #else
80
81 #ifdef __x86_64__
82
83 #include <xmmintrin.h> /* SSE 1 */
84 #include <emmintrin.h> /* SSE 2 */
85
86 #define __KERNEL_SSE2__
87
88 #endif
89
90 #endif
91
92 #ifndef _WIN32
93
94 #include <stdint.h>
95
96 #endif
97
98 #endif
99
100 CCL_NAMESPACE_BEGIN
101
102 /* Types
103  *
104  * Define simpler unsigned type names, and integer with defined number of bits.
105  * Also vector types, named to be compatible with OpenCL builtin types, while
106  * working for CUDA and C++ too. */
107
108 /* Shorter Unsigned Names */
109
110 #ifndef __KERNEL_OPENCL__
111
112 typedef unsigned char uchar;
113 typedef unsigned int uint;
114
115 #endif
116
117 #ifndef __KERNEL_GPU__
118
119 /* Fixed Bits Types */
120
121 #ifdef _WIN32
122
123 typedef signed char int8_t;
124 typedef unsigned char uint8_t;
125
126 typedef signed short int16_t;
127 typedef unsigned short uint16_t;
128
129 typedef signed int int32_t;
130 typedef unsigned int uint32_t;
131
132 typedef long long int64_t;
133 typedef unsigned long long uint64_t;
134
135 #ifdef __KERNEL_64_BIT__
136 typedef int64_t ssize_t;
137 #else
138 typedef int32_t ssize_t;
139 #endif
140
141 #endif
142
143 /* Generic Memory Pointer */
144
145 typedef uint64_t device_ptr;
146
147 /* Vector Types */
148
149 struct uchar2 {
150         uchar x, y;
151
152         __forceinline uchar operator[](int i) const { return *(&x + i); }
153         __forceinline uchar& operator[](int i) { return *(&x + i); }
154 };
155
156 struct uchar3 {
157         uchar x, y, z;
158
159         __forceinline uchar operator[](int i) const { return *(&x + i); }
160         __forceinline uchar& operator[](int i) { return *(&x + i); }
161 };
162
163 struct uchar4 {
164         uchar x, y, z, w;
165
166         __forceinline uchar operator[](int i) const { return *(&x + i); }
167         __forceinline uchar& operator[](int i) { return *(&x + i); }
168 };
169
170 struct int2 {
171         int x, y;
172
173         __forceinline int operator[](int i) const { return *(&x + i); }
174         __forceinline int& operator[](int i) { return *(&x + i); }
175 };
176
177 #ifdef __KERNEL_SSE__
178 struct __align(16) int3 {
179         union {
180                 __m128i m128;
181                 struct { int x, y, z, w; };
182         };
183
184         __forceinline int3() {}
185         __forceinline int3(const __m128i a) : m128(a) {}
186         __forceinline operator const __m128i&(void) const { return m128; }
187         __forceinline operator __m128i&(void) { return m128; }
188 #else
189 struct int3 {
190         int x, y, z, w;
191 #endif
192
193         __forceinline int operator[](int i) const { return *(&x + i); }
194         __forceinline int& operator[](int i) { return *(&x + i); }
195 };
196
197 #ifdef __KERNEL_SSE__
198 struct __align(16) int4 {
199         union {
200                 __m128i m128;
201                 struct { int x, y, z, w; };
202         };
203
204         __forceinline int4() {}
205         __forceinline int4(const __m128i a) : m128(a) {}
206         __forceinline operator const __m128i&(void) const { return m128; }
207         __forceinline operator __m128i&(void) { return m128; }
208 #else
209 struct int4 {
210         int x, y, z, w;
211 #endif
212
213         __forceinline int operator[](int i) const { return *(&x + i); }
214         __forceinline int& operator[](int i) { return *(&x + i); }
215 };
216
217 struct uint2 {
218         uint x, y;
219
220         __forceinline uint operator[](uint i) const { return *(&x + i); }
221         __forceinline uint& operator[](uint i) { return *(&x + i); }
222 };
223
224 struct uint3 {
225         uint x, y, z;
226
227         __forceinline uint operator[](uint i) const { return *(&x + i); }
228         __forceinline uint& operator[](uint i) { return *(&x + i); }
229 };
230
231 struct uint4 {
232         uint x, y, z, w;
233
234         __forceinline uint operator[](uint i) const { return *(&x + i); }
235         __forceinline uint& operator[](uint i) { return *(&x + i); }
236 };
237
238 struct float2 {
239         float x, y;
240
241         __forceinline float operator[](int i) const { return *(&x + i); }
242         __forceinline float& operator[](int i) { return *(&x + i); }
243 };
244
245 #ifdef __KERNEL_SSE__
246 struct __align(16) float3 {
247         union {
248                 __m128 m128;
249                 struct { float x, y, z, w; };
250         };
251
252         __forceinline float3() {}
253         __forceinline float3(const __m128 a) : m128(a) {}
254         __forceinline operator const __m128&(void) const { return m128; }
255         __forceinline operator __m128&(void) { return m128; }
256 #else
257 struct float3 {
258         float x, y, z, w;
259 #endif
260
261         __forceinline float operator[](int i) const { return *(&x + i); }
262         __forceinline float& operator[](int i) { return *(&x + i); }
263 };
264
265 #ifdef __KERNEL_SSE__
266 struct __align(16) float4 {
267         union {
268                 __m128 m128;
269                 struct { float x, y, z, w; };
270         };
271
272         __forceinline float4() {}
273         __forceinline float4(const __m128 a) : m128(a) {}
274         __forceinline operator const __m128&(void) const { return m128; }
275         __forceinline operator __m128&(void) { return m128; }
276 #else
277 struct float4 {
278         float x, y, z, w;
279 #endif
280
281         __forceinline float operator[](int i) const { return *(&x + i); }
282         __forceinline float& operator[](int i) { return *(&x + i); }
283 };
284
285 #endif
286
287 #ifndef __KERNEL_GPU__
288
289 /* Vector Type Constructors
290  * 
291  * OpenCL does not support C++ class, so we use these instead. */
292
293 __device_inline uchar2 make_uchar2(uchar x, uchar y)
294 {
295         uchar2 a = {x, y};
296         return a;
297 }
298
299 __device_inline uchar3 make_uchar3(uchar x, uchar y, uchar z)
300 {
301         uchar3 a = {x, y, z};
302         return a;
303 }
304
305 __device_inline uchar4 make_uchar4(uchar x, uchar y, uchar z, uchar w)
306 {
307         uchar4 a = {x, y, z, w};
308         return a;
309 }
310
311 __device_inline int2 make_int2(int x, int y)
312 {
313         int2 a = {x, y};
314         return a;
315 }
316
317 __device_inline int3 make_int3(int x, int y, int z)
318 {
319 #ifdef __KERNEL_SSE__
320         int3 a;
321         a.m128 = _mm_set_epi32(0, z, y, x);
322 #else
323         int3 a = {x, y, z, 0};
324 #endif
325
326         return a;
327 }
328
329 __device_inline int4 make_int4(int x, int y, int z, int w)
330 {
331 #ifdef __KERNEL_SSE__
332         int4 a;
333         a.m128 = _mm_set_epi32(w, z, y, x);
334 #else
335         int4 a = {x, y, z, w};
336 #endif
337
338         return a;
339 }
340
341 __device_inline uint2 make_uint2(uint x, uint y)
342 {
343         uint2 a = {x, y};
344         return a;
345 }
346
347 __device_inline uint3 make_uint3(uint x, uint y, uint z)
348 {
349         uint3 a = {x, y, z};
350         return a;
351 }
352
353 __device_inline uint4 make_uint4(uint x, uint y, uint z, uint w)
354 {
355         uint4 a = {x, y, z, w};
356         return a;
357 }
358
359 __device_inline float2 make_float2(float x, float y)
360 {
361         float2 a = {x, y};
362         return a;
363 }
364
365 __device_inline float3 make_float3(float x, float y, float z)
366 {
367 #ifdef __KERNEL_SSE__
368         float3 a;
369         a.m128 = _mm_set_ps(0.0f, z, y, x);
370 #else
371         float3 a = {x, y, z, 0.0f};
372 #endif
373
374         return a;
375 }
376
377 __device_inline float4 make_float4(float x, float y, float z, float w)
378 {
379 #ifdef __KERNEL_SSE__
380         float4 a;
381         a.m128 = _mm_set_ps(w, z, y, x);
382 #else
383         float4 a = {x, y, z, w};
384 #endif
385
386         return a;
387 }
388
389 __device_inline int align_up(int offset, int alignment)
390 {
391         return (offset + alignment - 1) & ~(alignment - 1);
392 }
393
394 __device_inline int3 make_int3(int i)
395 {
396 #ifdef __KERNEL_SSE__
397         int3 a;
398         a.m128 = _mm_set1_epi32(i);
399 #else
400         int3 a = {i, i, i, i};
401 #endif
402
403         return a;
404 }
405
406 __device_inline int4 make_int4(int i)
407 {
408 #ifdef __KERNEL_SSE__
409         int4 a;
410         a.m128 = _mm_set1_epi32(i);
411 #else
412         int4 a = {i, i, i, i};
413 #endif
414
415         return a;
416 }
417
418 __device_inline float3 make_float3(float f)
419 {
420 #ifdef __KERNEL_SSE__
421         float3 a;
422         a.m128 = _mm_set1_ps(f);
423 #else
424         float3 a = {f, f, f, f};
425 #endif
426
427         return a;
428 }
429
430 __device_inline float4 make_float4(float f)
431 {
432 #ifdef __KERNEL_SSE__
433         float4 a;
434         a.m128 = _mm_set1_ps(f);
435 #else
436         float4 a = {f, f, f, f};
437 #endif
438
439         return a;
440 }
441
442 __device_inline float4 make_float4(const int4& i)
443 {
444 #ifdef __KERNEL_SSE__
445         float4 a;
446         a.m128 = _mm_cvtepi32_ps(i.m128);
447 #else
448         float4 a = {(float)i.x, (float)i.y, (float)i.z, (float)i.w};
449 #endif
450
451         return a;
452 }
453
454 __device_inline int4 make_int4(const float3& f)
455 {
456 #ifdef __KERNEL_SSE__
457         int4 a;
458         a.m128 = _mm_cvtps_epi32(f.m128);
459 #else
460         int4 a = {(int)f.x, (int)f.y, (int)f.z, (int)f.w};
461 #endif
462
463         return a;
464 }
465
466 #endif
467
468 CCL_NAMESPACE_END
469
470 #endif /* __UTIL_TYPES_H__ */
471