Fix build error on Windows 32 bit.
[blender-staging.git] / intern / cycles / kernel / kernel_globals.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 /* Constant Globals */
18
19 #ifndef __KERNEL_GLOBALS_H__
20 #define __KERNEL_GLOBALS_H__
21
22 #ifdef __KERNEL_CPU__
23 #  include "util/util_vector.h"
24 #endif
25
26 #ifdef __KERNEL_OPENCL__
27 #  include "util/util_atomic.h"
28 #endif
29
30 CCL_NAMESPACE_BEGIN
31
32 /* On the CPU, we pass along the struct KernelGlobals to nearly everywhere in
33  * the kernel, to access constant data. These are all stored as "textures", but
34  * these are really just standard arrays. We can't use actually globals because
35  * multiple renders may be running inside the same process. */
36
37 #ifdef __KERNEL_CPU__
38
39 #  ifdef __OSL__
40 struct OSLGlobals;
41 struct OSLThreadData;
42 struct OSLShadingSystem;
43 #  endif
44
45 struct Intersection;
46 struct VolumeStep;
47
48 typedef struct KernelGlobals {
49 #  define KERNEL_TEX(type, name) texture<type> name;
50 #  include "kernel/kernel_textures.h"
51
52         KernelData __data;
53
54 #  ifdef __OSL__
55         /* On the CPU, we also have the OSL globals here. Most data structures are shared
56          * with SVM, the difference is in the shaders and object/mesh attributes. */
57         OSLGlobals *osl;
58         OSLShadingSystem *osl_ss;
59         OSLThreadData *osl_tdata;
60 #  endif
61
62         /* **** Run-time data ****  */
63
64         /* Heap-allocated storage for transparent shadows intersections. */
65         Intersection *transparent_shadow_intersections;
66
67         /* Storage for decoupled volume steps. */
68         VolumeStep *decoupled_volume_steps[2];
69         int decoupled_volume_steps_index;
70
71         /* split kernel */
72         SplitData split_data;
73         SplitParams split_param_data;
74
75         int2 global_size;
76         int2 global_id;
77 } KernelGlobals;
78
79 #endif  /* __KERNEL_CPU__ */
80
81 /* For CUDA, constant memory textures must be globals, so we can't put them
82  * into a struct. As a result we don't actually use this struct and use actual
83  * globals and simply pass along a NULL pointer everywhere, which we hope gets
84  * optimized out. */
85
86 #ifdef __KERNEL_CUDA__
87
88 __constant__ KernelData __data;
89 typedef struct KernelGlobals {
90         /* NOTE: Keep the size in sync with SHADOW_STACK_MAX_HITS. */
91         Intersection hits_stack[64];
92 } KernelGlobals;
93
94 #  define KERNEL_TEX(type, name) const __constant__ __device__ type *name;
95 #  include "kernel/kernel_textures.h"
96
97 #endif  /* __KERNEL_CUDA__ */
98
99 /* OpenCL */
100
101 #ifdef __KERNEL_OPENCL__
102
103 #  define KERNEL_TEX(type, name) \
104 typedef type name##_t;
105 #  include "kernel/kernel_textures.h"
106
107 typedef ccl_addr_space struct KernelGlobals {
108         ccl_constant KernelData *data;
109         ccl_global char *buffers[8];
110
111 #  define KERNEL_TEX(type, name) \
112         TextureInfo name;
113 #  include "kernel/kernel_textures.h"
114
115 #  ifdef __SPLIT_KERNEL__
116         SplitData split_data;
117         SplitParams split_param_data;
118 #  endif
119 } KernelGlobals;
120
121 #define KERNEL_BUFFER_PARAMS \
122         ccl_global char *buffer0, \
123         ccl_global char *buffer1, \
124         ccl_global char *buffer2, \
125         ccl_global char *buffer3, \
126         ccl_global char *buffer4, \
127         ccl_global char *buffer5, \
128         ccl_global char *buffer6, \
129         ccl_global char *buffer7
130
131 #define KERNEL_BUFFER_ARGS buffer0, buffer1, buffer2, buffer3, buffer4, buffer5, buffer6, buffer7
132
133 ccl_device_inline void kernel_set_buffer_pointers(KernelGlobals *kg, KERNEL_BUFFER_PARAMS)
134 {
135 #ifdef __SPLIT_KERNEL__
136         if(ccl_local_id(0) + ccl_local_id(1) == 0)
137 #endif
138         {
139                 kg->buffers[0] = buffer0;
140                 kg->buffers[1] = buffer1;
141                 kg->buffers[2] = buffer2;
142                 kg->buffers[3] = buffer3;
143                 kg->buffers[4] = buffer4;
144                 kg->buffers[5] = buffer5;
145                 kg->buffers[6] = buffer6;
146                 kg->buffers[7] = buffer7;
147         }
148
149 #  ifdef __SPLIT_KERNEL__
150         ccl_barrier(CCL_LOCAL_MEM_FENCE);
151 #  endif
152 }
153
154 ccl_device_inline void kernel_set_buffer_info(KernelGlobals *kg)
155 {
156 #  ifdef __SPLIT_KERNEL__
157         if(ccl_local_id(0) + ccl_local_id(1) == 0)
158 #  endif
159         {
160                 ccl_global TextureInfo *info = (ccl_global TextureInfo*)kg->buffers[0];
161
162 #  define KERNEL_TEX(type, name) \
163                 kg->name = *(info++);
164 #  include "kernel/kernel_textures.h"
165         }
166
167 #  ifdef __SPLIT_KERNEL__
168         ccl_barrier(CCL_LOCAL_MEM_FENCE);
169 #  endif
170 }
171
172 #endif  /* __KERNEL_OPENCL__ */
173
174 /* Interpolated lookup table access */
175
176 ccl_device float lookup_table_read(KernelGlobals *kg, float x, int offset, int size)
177 {
178         x = saturate(x)*(size-1);
179
180         int index = min(float_to_int(x), size-1);
181         int nindex = min(index+1, size-1);
182         float t = x - index;
183
184         float data0 = kernel_tex_fetch(__lookup_table, index + offset);
185         if(t == 0.0f)
186                 return data0;
187
188         float data1 = kernel_tex_fetch(__lookup_table, nindex + offset);
189         return (1.0f - t)*data0 + t*data1;
190 }
191
192 ccl_device float lookup_table_read_2D(KernelGlobals *kg, float x, float y, int offset, int xsize, int ysize)
193 {
194         y = saturate(y)*(ysize-1);
195
196         int index = min(float_to_int(y), ysize-1);
197         int nindex = min(index+1, ysize-1);
198         float t = y - index;
199
200         float data0 = lookup_table_read(kg, x, offset + xsize*index, xsize);
201         if(t == 0.0f)
202                 return data0;
203
204         float data1 = lookup_table_read(kg, x, offset + xsize*nindex, xsize);
205         return (1.0f - t)*data0 + t*data1;
206 }
207
208 CCL_NAMESPACE_END
209
210 #endif  /* __KERNEL_GLOBALS_H__ */