5dbea4481a3862477224e7fc74955b052498f327
[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 CCL_NAMESPACE_BEGIN
20
21 /* On the CPU, we pass along the struct KernelGlobals to nearly everywhere in
22  * the kernel, to access constant data. These are all stored as "textures", but
23  * these are really just standard arrays. We can't use actually globals because
24  * multiple renders may be running inside the same process. */
25
26 #ifdef __KERNEL_CPU__
27
28 #  ifdef __OSL__
29 struct OSLGlobals;
30 struct OSLThreadData;
31 struct OSLShadingSystem;
32 #  endif
33
34 struct Intersection;
35 struct VolumeStep;
36
37 typedef struct KernelGlobals {
38         texture_image_uchar4 texture_byte4_images[TEX_NUM_BYTE4_CPU];
39         texture_image_float4 texture_float4_images[TEX_NUM_FLOAT4_CPU];
40         texture_image_half4 texture_half4_images[TEX_NUM_HALF4_CPU];
41         texture_image_float texture_float_images[TEX_NUM_FLOAT_CPU];
42         texture_image_uchar texture_byte_images[TEX_NUM_BYTE_CPU];
43         texture_image_half texture_half_images[TEX_NUM_HALF_CPU];
44
45 #  define KERNEL_TEX(type, ttype, name) ttype name;
46 #  define KERNEL_IMAGE_TEX(type, ttype, name)
47 #  include "kernel_textures.h"
48
49         KernelData __data;
50
51 #  ifdef __OSL__
52         /* On the CPU, we also have the OSL globals here. Most data structures are shared
53          * with SVM, the difference is in the shaders and object/mesh attributes. */
54         OSLGlobals *osl;
55         OSLShadingSystem *osl_ss;
56         OSLThreadData *osl_tdata;
57 #  endif
58
59         /* **** Run-time data ****  */
60
61         /* Heap-allocated storage for transparent shadows intersections. */
62         Intersection *transparent_shadow_intersections;
63
64         /* Storage for decoupled volume steps. */
65         VolumeStep *decoupled_volume_steps[2];
66         int decoupled_volume_steps_index;
67
68         /* split kernel */
69         SplitData split_data;
70         SplitParams split_param_data;
71
72         int2 global_size;
73         int2 global_id;
74 } KernelGlobals;
75
76 #endif  /* __KERNEL_CPU__ */
77
78 /* For CUDA, constant memory textures must be globals, so we can't put them
79  * into a struct. As a result we don't actually use this struct and use actual
80  * globals and simply pass along a NULL pointer everywhere, which we hope gets
81  * optimized out. */
82
83 #ifdef __KERNEL_CUDA__
84
85 __constant__ KernelData __data;
86 typedef struct KernelGlobals {
87         /* NOTE: Keep the size in sync with SHADOW_STACK_MAX_HITS. */
88         Intersection hits_stack[64];
89 } KernelGlobals;
90
91 #  ifdef __KERNEL_CUDA_TEX_STORAGE__
92 #    define KERNEL_TEX(type, ttype, name) ttype name;
93 #  else
94 #    define KERNEL_TEX(type, ttype, name) const __constant__ __device__ type *name;
95 #  endif
96 #  define KERNEL_IMAGE_TEX(type, ttype, name) ttype name;
97 #  include "kernel_textures.h"
98
99 #endif  /* __KERNEL_CUDA__ */
100
101 /* OpenCL */
102
103 #ifdef __KERNEL_OPENCL__
104
105 typedef ccl_addr_space struct KernelGlobals {
106         ccl_constant KernelData *data;
107
108 #  define KERNEL_TEX(type, ttype, name) \
109         ccl_global type *name;
110 #  include "kernel_textures.h"
111
112 #  ifdef __SPLIT_KERNEL__
113         ShaderData *sd_input;
114         Intersection *isect_shadow;
115         SplitData split_data;
116         SplitParams split_param_data;
117 #  endif
118 } KernelGlobals;
119
120 #endif  /* __KERNEL_OPENCL__ */
121
122 /* Interpolated lookup table access */
123
124 ccl_device float lookup_table_read(KernelGlobals *kg, float x, int offset, int size)
125 {
126         x = saturate(x)*(size-1);
127
128         int index = min(float_to_int(x), size-1);
129         int nindex = min(index+1, size-1);
130         float t = x - index;
131
132         float data0 = kernel_tex_fetch(__lookup_table, index + offset);
133         if(t == 0.0f)
134                 return data0;
135
136         float data1 = kernel_tex_fetch(__lookup_table, nindex + offset);
137         return (1.0f - t)*data0 + t*data1;
138 }
139
140 ccl_device float lookup_table_read_2D(KernelGlobals *kg, float x, float y, int offset, int xsize, int ysize)
141 {
142         y = saturate(y)*(ysize-1);
143
144         int index = min(float_to_int(y), ysize-1);
145         int nindex = min(index+1, ysize-1);
146         float t = y - index;
147
148         float data0 = lookup_table_read(kg, x, offset + xsize*index, xsize);
149         if(t == 0.0f)
150                 return data0;
151
152         float data1 = lookup_table_read(kg, x, offset + xsize*nindex, xsize);
153         return (1.0f - t)*data0 + t*data1;
154 }
155
156 CCL_NAMESPACE_END
157