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