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