Cleanup: Avoid duplicative defines for CPU textures, use the ones from util_texture.h
[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 typedef struct KernelGlobals {
35         texture_image_uchar4 texture_byte4_images[TEX_NUM_BYTE4_IMAGES_CPU];
36         texture_image_float4 texture_float4_images[TEX_NUM_FLOAT4_IMAGES_CPU];
37
38 #  define KERNEL_TEX(type, ttype, name) ttype name;
39 #  define KERNEL_IMAGE_TEX(type, ttype, name)
40 #  include "kernel_textures.h"
41
42         KernelData __data;
43
44 #  ifdef __OSL__
45         /* On the CPU, we also have the OSL globals here. Most data structures are shared
46          * with SVM, the difference is in the shaders and object/mesh attributes. */
47         OSLGlobals *osl;
48         OSLShadingSystem *osl_ss;
49         OSLThreadData *osl_tdata;
50 #  endif
51
52 } KernelGlobals;
53
54 #endif  /* __KERNEL_CPU__ */
55
56 /* For CUDA, constant memory textures must be globals, so we can't put them
57  * into a struct. As a result we don't actually use this struct and use actual
58  * globals and simply pass along a NULL pointer everywhere, which we hope gets
59  * optimized out. */
60
61 #ifdef __KERNEL_CUDA__
62
63 __constant__ KernelData __data;
64 typedef struct KernelGlobals {} KernelGlobals;
65
66 #  ifdef __KERNEL_CUDA_TEX_STORAGE__
67 #    define KERNEL_TEX(type, ttype, name) ttype name;
68 #  else
69 #    define KERNEL_TEX(type, ttype, name) const __constant__ __device__ type *name;
70 #  endif
71 #  define KERNEL_IMAGE_TEX(type, ttype, name) ttype name;
72 #  include "kernel_textures.h"
73
74 #endif  /* __KERNEL_CUDA__ */
75
76 /* OpenCL */
77
78 #ifdef __KERNEL_OPENCL__
79
80 typedef ccl_addr_space struct KernelGlobals {
81         ccl_constant KernelData *data;
82
83 #  define KERNEL_TEX(type, ttype, name) \
84         ccl_global type *name;
85 #  include "kernel_textures.h"
86
87 #  ifdef __SPLIT_KERNEL__
88         ShaderData *sd_input;
89         Intersection *isect_shadow;
90 #  endif
91 } KernelGlobals;
92
93 #endif  /* __KERNEL_OPENCL__ */
94
95 /* Interpolated lookup table access */
96
97 ccl_device float lookup_table_read(KernelGlobals *kg, float x, int offset, int size)
98 {
99         x = saturate(x)*(size-1);
100
101         int index = min(float_to_int(x), size-1);
102         int nindex = min(index+1, size-1);
103         float t = x - index;
104
105         float data0 = kernel_tex_fetch(__lookup_table, index + offset);
106         if(t == 0.0f)
107                 return data0;
108
109         float data1 = kernel_tex_fetch(__lookup_table, nindex + offset);
110         return (1.0f - t)*data0 + t*data1;
111 }
112
113 ccl_device float lookup_table_read_2D(KernelGlobals *kg, float x, float y, int offset, int xsize, int ysize)
114 {
115         y = saturate(y)*(ysize-1);
116
117         int index = min(float_to_int(y), ysize-1);
118         int nindex = min(index+1, ysize-1);
119         float t = y - index;
120
121         float data0 = lookup_table_read(kg, x, offset + xsize*index, xsize);
122         if(t == 0.0f)
123                 return data0;
124
125         float data1 = lookup_table_read(kg, x, offset + xsize*nindex, xsize);
126         return (1.0f - t)*data0 + t*data1;
127 }
128
129 CCL_NAMESPACE_END
130