Cycles: svn merge -r39870:r40266 https://svn.blender.org/svnroot/bf-blender/trunk...
[blender-staging.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 #ifdef __GNUC__
40 #define __device_inline static inline __attribute__((always_inline))
41 #else
42 #define __device_inline static __forceinline
43 #endif
44
45 #endif
46
47 /* SIMD Types */
48
49 #ifndef __KERNEL_GPU__
50
51 #include <emmintrin.h>
52 #include <xmmintrin.h>
53
54 #endif
55
56 #ifndef _WIN32
57 #ifndef __KERNEL_GPU__
58
59 #include <stdint.h>
60
61 #endif
62 #endif
63
64 CCL_NAMESPACE_BEGIN
65
66 /* Types
67  *
68  * Define simpler unsigned type names, and integer with defined number of bits.
69  * Also vector types, named to be compatible with OpenCL builtin types, while
70  * working for CUDA and C++ too. */
71
72 /* Shorter Unsigned Names */
73
74 #ifndef __KERNEL_OPENCL__
75
76 typedef unsigned char uchar;
77 typedef unsigned int uint;
78
79 #endif
80
81 #ifndef __KERNEL_GPU__
82
83 /* Fixed Bits Types */
84
85 #ifdef _WIN32
86
87 typedef signed char int8_t;
88 typedef unsigned char uint8_t;
89
90 typedef signed short int16_t;
91 typedef unsigned short uint16_t;
92
93 typedef signed int int32_t;
94 typedef unsigned int uint32_t;
95
96 typedef long long int64_t;
97 typedef unsigned long long uint64_t;
98
99 #endif
100
101 /* Generic Memory Pointer */
102
103 typedef uint64_t device_ptr;
104
105 /* Vector Types */
106
107 struct uchar2 {
108         uchar x, y;
109
110         uchar operator[](int i) const { return *(&x + i); }
111         uchar& operator[](int i) { return *(&x + i); }
112 };
113
114 struct uchar3 {
115         uchar x, y, z;
116
117         uchar operator[](int i) const { return *(&x + i); }
118         uchar& operator[](int i) { return *(&x + i); }
119 };
120
121 struct uchar4 {
122         uchar x, y, z, w;
123
124         uchar operator[](int i) const { return *(&x + i); }
125         uchar& operator[](int i) { return *(&x + i); }
126 };
127
128 struct int2 {
129         int x, y;
130
131         int operator[](int i) const { return *(&x + i); }
132         int& operator[](int i) { return *(&x + i); }
133 };
134
135 struct int3 {
136         int x, y, z;
137
138         int operator[](int i) const { return *(&x + i); }
139         int& operator[](int i) { return *(&x + i); }
140 };
141
142 struct int4 {
143         int x, y, z, w;
144
145         int operator[](int i) const { return *(&x + i); }
146         int& operator[](int i) { return *(&x + i); }
147 };
148
149 struct uint2 {
150         uint x, y;
151
152         uint operator[](int i) const { return *(&x + i); }
153         uint& operator[](int i) { return *(&x + i); }
154 };
155
156 struct uint3 {
157         uint x, y, z;
158
159         uint operator[](int i) const { return *(&x + i); }
160         uint& operator[](int i) { return *(&x + i); }
161 };
162
163 struct uint4 {
164         uint x, y, z, w;
165
166         uint operator[](int i) const { return *(&x + i); }
167         uint& operator[](int i) { return *(&x + i); }
168 };
169
170 struct float2 {
171         float x, y;
172
173         float operator[](int i) const { return *(&x + i); }
174         float& operator[](int i) { return *(&x + i); }
175 };
176
177 struct float3 {
178         float x, y, z;
179
180 #ifdef WITH_OPENCL
181         float w;
182 #endif
183
184         float operator[](int i) const { return *(&x + i); }
185         float& operator[](int i) { return *(&x + i); }
186 };
187
188 struct float4 {
189         float x, y, z, w;
190
191         float operator[](int i) const { return *(&x + i); }
192         float& operator[](int i) { return *(&x + i); }
193 };
194
195 #endif
196
197 #ifndef __KERNEL_GPU__
198
199 /* Vector Type Constructors
200  * 
201  * OpenCL does not support C++ class, so we use these instead. */
202
203 __device uchar2 make_uchar2(uchar x, uchar y)
204 {
205         uchar2 a = {x, y};
206         return a;
207 }
208
209 __device uchar3 make_uchar3(uchar x, uchar y, uchar z)
210 {
211         uchar3 a = {x, y, z};
212         return a;
213 }
214
215 __device uchar4 make_uchar4(uchar x, uchar y, uchar z, uchar w)
216 {
217         uchar4 a = {x, y, z, w};
218         return a;
219 }
220
221 __device int2 make_int2(int x, int y)
222 {
223         int2 a = {x, y};
224         return a;
225 }
226
227 __device int3 make_int3(int x, int y, int z)
228 {
229         int3 a = {x, y, z};
230         return a;
231 }
232
233 __device int4 make_int4(int x, int y, int z, int w)
234 {
235         int4 a = {x, y, z, w};
236         return a;
237 }
238
239 __device uint2 make_uint2(uint x, uint y)
240 {
241         uint2 a = {x, y};
242         return a;
243 }
244
245 __device uint3 make_uint3(uint x, uint y, uint z)
246 {
247         uint3 a = {x, y, z};
248         return a;
249 }
250
251 __device uint4 make_uint4(uint x, uint y, uint z, uint w)
252 {
253         uint4 a = {x, y, z, w};
254         return a;
255 }
256
257 __device float2 make_float2(float x, float y)
258 {
259         float2 a = {x, y};
260         return a;
261 }
262
263 __device float3 make_float3(float x, float y, float z)
264 {
265 #ifdef WITH_OPENCL
266         float3 a = {x, y, z, 0.0f};
267 #else
268         float3 a = {x, y, z};
269 #endif
270         return a;
271 }
272
273 __device float4 make_float4(float x, float y, float z, float w)
274 {
275         float4 a = {x, y, z, w};
276         return a;
277 }
278
279 #endif
280
281 CCL_NAMESPACE_END
282
283 #endif /* __UTIL_TYPES_H__ */
284