Cycles: Use native saturate function for CUDA
[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
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
78
79 /* OpenCL */
80
81 #ifdef __KERNEL_OPENCL__
82
83 typedef 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 } KernelGlobals;
90
91 #endif
92
93 /* Interpolated lookup table access */
94
95 ccl_device float lookup_table_read(KernelGlobals *kg, float x, int offset, int size)
96 {
97         x = saturate(x)*(size-1);
98
99         int index = min(float_to_int(x), size-1);
100         int nindex = min(index+1, size-1);
101         float t = x - index;
102
103         float data0 = kernel_tex_fetch(__lookup_table, index + offset);
104         if(t == 0.0f)
105                 return data0;
106
107         float data1 = kernel_tex_fetch(__lookup_table, nindex + offset);
108         return (1.0f - t)*data0 + t*data1;
109 }
110
111 ccl_device float lookup_table_read_2D(KernelGlobals *kg, float x, float y, int offset, int xsize, int ysize)
112 {
113         y = saturate(y)*(ysize-1);
114
115         int index = min(float_to_int(y), ysize-1);
116         int nindex = min(index+1, ysize-1);
117         float t = y - index;
118
119         float data0 = lookup_table_read(kg, x, offset + xsize*index, xsize);
120         if(t == 0.0f)
121                 return data0;
122
123         float data1 = lookup_table_read(kg, x, offset + xsize*nindex, xsize);
124         return (1.0f - t)*data0 + t*data1;
125 }
126
127 CCL_NAMESPACE_END
128