Cycles: relicense GNU GPL source code to Apache version 2.0.
[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   512
35 #define MAX_FLOAT_IMAGES  5
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 #define KERNEL_TEX(type, ttype, name) ttype name;
70 #define KERNEL_IMAGE_TEX(type, ttype, name) ttype name;
71 #include "kernel_textures.h"
72
73 #endif
74
75 /* OpenCL */
76
77 #ifdef __KERNEL_OPENCL__
78
79 typedef struct KernelGlobals {
80         __constant KernelData *data;
81
82 #define KERNEL_TEX(type, ttype, name) \
83         __global type *name;
84 #include "kernel_textures.h"
85 } KernelGlobals;
86
87 #endif
88
89 /* Interpolated lookup table access */
90
91 __device float lookup_table_read(KernelGlobals *kg, float x, int offset, int size)
92 {
93         x = clamp(x, 0.0f, 1.0f)*(size-1);
94
95         int index = min(float_to_int(x), size-1);
96         int nindex = min(index+1, size-1);
97         float t = x - index;
98
99         float data0 = kernel_tex_fetch(__lookup_table, index + offset);
100         if(t == 0.0f)
101                 return data0;
102
103         float data1 = kernel_tex_fetch(__lookup_table, nindex + offset);
104         return (1.0f - t)*data0 + t*data1;
105 }
106
107 __device float lookup_table_read_2D(KernelGlobals *kg, float x, float y, int offset, int xsize, int ysize)
108 {
109         y = clamp(y, 0.0f, 1.0f)*(ysize-1);
110
111         int index = min(float_to_int(y), ysize-1);
112         int nindex = min(index+1, ysize-1);
113         float t = y - index;
114
115         float data0 = lookup_table_read(kg, x, offset + xsize*index, xsize);
116         if(t == 0.0f)
117                 return data0;
118
119         float data1 = lookup_table_read(kg, x, offset + xsize*nindex, xsize);
120         return (1.0f - t)*data0 + t*data1;
121 }
122
123 CCL_NAMESPACE_END
124