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