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