intern/cycles/kernel/kernel_types.h

   1 /*
   2  * Copyright 2011, Blender Foundation.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  */
  18
  19 #ifndef __KERNEL_TYPES_H__
  20 #define __KERNEL_TYPES_H__
  21
  22 #include "kernel_math.h"
  23
  24 #include "svm/svm_types.h"
  25
  26 CCL_NAMESPACE_BEGIN
  27
  28 #define OBJECT_SIZE 16
  29 #define LIGHT_SIZE      4
  30
  31 #define __SOBOL__
  32 #define __INSTANCING__
  33 #define __DPDU__
  34 #define __UV__
  35 #define __BACKGROUND__
  36 #define __CAUSTICS_TRICKS__
  37 #define __VISIBILITY_FLAG__
  38 #define __RAY_DIFFERENTIALS__
  39 #define __CAMERA_CLIPPING__
  40 #define __INTERSECTION_REFINE__
  41
  42 #ifndef __KERNEL_OPENCL__
  43 #define __SVM__
  44 #define __EMISSION__
  45 #define __TEXTURES__
  46 #define __HOLDOUT__
  47 //#define __MULTI_CLOSURE__
  48 //#define __TRANSPARENT_SHADOWS__
  49 //#define __MULTI_LIGHT__
  50 #endif
  51
  52 #ifdef __KERNEL_CPU__
  53 //#define __OSL__
  54 #endif
  55
  56 //#define __SOBOL_FULL_SCREEN__
  57 //#define __MODIFY_TP__
  58 //#define __QBVH__
  59
  60 /* Path Tracing */
  61
  62 enum PathTraceDimension {
  63         PRNG_FILTER_U = 0,
  64         PRNG_FILTER_V = 1,
  65         PRNG_LENS_U = 2,
  66         PRNG_LENS_V = 3,
  67         PRNG_BASE_NUM = 4,
  68
  69         PRNG_BSDF_U = 0,
  70         PRNG_BSDF_V = 1,
  71         PRNG_BSDF = 2,
  72         PRNG_LIGHT = 3,
  73         PRNG_LIGHT_U = 4,
  74         PRNG_LIGHT_V = 5,
  75         PRNG_LIGHT_F = 6,
  76         PRNG_TERMINATE = 7,
  77         PRNG_BOUNCE_NUM = 8
  78 };
  79
  80 /* these flag values correspond exactly to OSL defaults, so be careful not to
  81  * change this, or if you do, set the "raytypes" shading system attribute with
  82  * your own new ray types and bitflag values */
  83
  84 enum PathRayFlag {
  85         PATH_RAY_CAMERA = 1,
  86         PATH_RAY_SHADOW = 2,
  87         PATH_RAY_REFLECT = 4,
  88         PATH_RAY_TRANSMIT = 8,
  89         PATH_RAY_DIFFUSE = 16,
  90         PATH_RAY_GLOSSY = 32,
  91         PATH_RAY_SINGULAR = 64,
  92         PATH_RAY_TRANSPARENT = 128,
  93
  94         PATH_RAY_ALL = (1|2|4|8|16|32|64|128)
  95 };
  96
  97 /* Closure Label */
  98
  99 typedef enum ClosureLabel {
 100         LABEL_NONE = 0,
 101         LABEL_CAMERA = 1,
 102         LABEL_LIGHT = 2,
 103         LABEL_BACKGROUND = 4,
 104         LABEL_TRANSMIT = 8,
 105         LABEL_REFLECT = 16,
 106         LABEL_VOLUME = 32,
 107         LABEL_OBJECT = 64,
 108         LABEL_DIFFUSE = 128,
 109         LABEL_GLOSSY = 256,
 110         LABEL_SINGULAR = 512,
 111         LABEL_TRANSPARENT = 1024,
 112         LABEL_STOP = 2048
 113 } ClosureLabel;
 114
 115 /* Shader Flag */
 116
 117 typedef enum ShaderFlag {
 118         SHADER_SMOOTH_NORMAL = (1 << 31),
 119         SHADER_CAST_SHADOW = (1 << 30),
 120         SHADER_AREA_LIGHT = (1 << 29),
 121
 122         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT)
 123 } ShaderFlag;
 124
 125 /* Light Type */
 126
 127 typedef enum LightType {
 128         LIGHT_POINT,
 129         LIGHT_DISTANT,
 130         LIGHT_AREA
 131 } LightType;
 132
 133 /* Differential */
 134
 135 typedef struct differential3 {
 136         float3 dx;
 137         float3 dy;
 138 } differential3;
 139
 140 typedef struct differential {
 141         float dx;
 142         float dy;
 143 } differential;
 144
 145 /* Ray */
 146
 147 typedef struct Ray {
 148         float3 P;
 149         float3 D;
 150         float t;
 151
 152 #ifdef __RAY_DIFFERENTIALS__
 153         differential3 dP;
 154         differential3 dD;
 155 #endif
 156 } Ray;
 157
 158 /* Intersection */
 159
 160 typedef struct Intersection {
 161         float t, u, v;
 162         int prim;
 163         int object;
 164 } Intersection;
 165
 166 /* Attributes */
 167
 168 typedef enum AttributeElement {
 169         ATTR_ELEMENT_FACE,
 170         ATTR_ELEMENT_VERTEX,
 171         ATTR_ELEMENT_CORNER,
 172         ATTR_ELEMENT_VALUE,
 173         ATTR_ELEMENT_NONE
 174 } AttributeElement;
 175
 176 /* Closure data */
 177
 178 #define MAX_CLOSURE 8
 179
 180 typedef struct ShaderClosure {
 181         ClosureType type;
 182         float3 weight;
 183
 184 #ifdef __MULTI_CLOSURE__
 185         float sample_weight;
 186 #endif
 187
 188 #ifdef __OSL__
 189         void *prim;
 190 #else
 191         float data0;
 192         float data1;
 193 #endif
 194
 195 } ShaderClosure;
 196
 197 /* Shader Data
 198  *
 199  * Main shader state at a point on the surface or in a volume. All coordinates
 200  * are in world space. */
 201
 202 enum ShaderDataFlag {
 203         /* runtime flags */
 204         SD_BACKFACING = 1,              /* backside of surface? */
 205         SD_EMISSION = 2,                /* have emissive closure? */
 206         SD_BSDF = 4,                    /* have bsdf closure? */
 207         SD_BSDF_HAS_EVAL = 8,   /* have non-singular bsdf closure? */
 208         SD_BSDF_GLOSSY = 16,    /* have glossy bsdf */
 209         SD_HOLDOUT = 32,                /* have holdout closure? */
 210         SD_VOLUME = 64,                 /* have volume closure? */
 211
 212         /* shader flags */
 213         SD_SAMPLE_AS_LIGHT = 128,                       /* direct light sample */
 214         SD_HAS_SURFACE_TRANSPARENT = 256,       /* has surface transparency */
 215         SD_HAS_VOLUME = 512,                            /* has volume shader */
 216         SD_HOMOGENEOUS_VOLUME = 1024            /* has homogeneous volume */
 217 };
 218
 219 typedef struct ShaderData {
 220         /* position */
 221         float3 P;
 222         /* smooth normal for shading */
 223         float3 N;
 224         /* true geometric normal */
 225         float3 Ng;
 226         /* view/incoming direction */
 227         float3 I;
 228         /* shader id */
 229         int shader;
 230         /* booleans describing shader, see ShaderDataFlag */
 231         int flag;
 232
 233         /* primitive id if there is one, ~0 otherwise */
 234         int prim;
 235         /* parametric coordinates
 236          * - barycentric weights for triangles */
 237         float u, v;
 238         /* object id if there is one, ~0 otherwise */
 239         int object;
 240
 241 #ifdef __RAY_DIFFERENTIALS__
 242         /* differential of P. these are orthogonal to Ng, not N */
 243         differential3 dP;
 244         /* differential of I */
 245         differential3 dI;
 246         /* differential of u, v */
 247         differential du;
 248         differential dv;
 249 #endif
 250 #ifdef __DPDU__
 251         /* differential of P w.r.t. parametric coordinates. note that dPdu is
 252          * not readily suitable as a tangent for shading on triangles. */
 253         float3 dPdu, dPdv;
 254 #endif
 255
 256 #ifdef __MULTI_CLOSURE__
 257         /* Closure data, we store a fixed array of closures */
 258         ShaderClosure closure[MAX_CLOSURE];
 259         int num_closure;
 260         float randb_closure;
 261 #else
 262         /* Closure data, with a single sampled closure for low memory usage */
 263         ShaderClosure closure;
 264 #endif
 265
 266 #ifdef __OSL__
 267         /* OSL context */
 268         void *osl_ctx;
 269 #endif
 270 } ShaderData;
 271
 272 /* Constrant Kernel Data */
 273
 274 typedef struct KernelCamera {
 275         /* type */
 276         int ortho;
 277         int pad;
 278
 279         /* size */
 280         int width, height;
 281
 282         /* matrices */
 283         Transform cameratoworld;
 284         Transform rastertocamera;
 285
 286         /* differentials */
 287         float3 dx;
 288 #ifndef WITH_OPENCL
 289         float pad1;
 290 #endif
 291         float3 dy;
 292 #ifndef WITH_OPENCL
 293         float pad2;
 294 #endif
 295
 296         /* depth of field */
 297         float aperturesize;
 298         float blades;
 299         float bladesrotation;
 300         float focaldistance;
 301
 302         /* motion blur */
 303         float shutteropen;
 304         float shutterclose;
 305
 306         /* clipping */
 307         float nearclip;
 308         float cliplength;
 309
 310         /* more matrices */
 311         Transform screentoworld;
 312         Transform rastertoworld;
 313         Transform ndctoworld;
 314         Transform worldtoscreen;
 315         Transform worldtoraster;
 316         Transform worldtondc;
 317         Transform worldtocamera;
 318 } KernelCamera;
 319
 320 typedef struct KernelFilm {
 321         float exposure;
 322         int pad1, pad2, pad3;
 323 } KernelFilm;
 324
 325 typedef struct KernelBackground {
 326         /* only shader index */
 327         int shader;
 328         int transparent;
 329         int pad1, pad2;
 330 } KernelBackground;
 331
 332 typedef struct KernelSunSky {
 333         /* sun direction in spherical and cartesian */
 334         float theta, phi, pad3, pad4;
 335         float3 dir;
 336 #ifndef WITH_OPENCL
 337         float pad;
 338 #endif
 339
 340         /* perez function parameters */
 341         float zenith_Y, zenith_x, zenith_y, pad2;
 342         float perez_Y[5], perez_x[5], perez_y[5];
 343         float pad5;
 344 } KernelSunSky;
 345
 346 typedef struct KernelIntegrator {
 347         /* emission */
 348         int use_direct_light;
 349         int num_distribution;
 350         int num_all_lights;
 351         float pdf_triangles;
 352         float pdf_lights;
 353         float pdf_pad;
 354
 355         /* bounces */
 356         int min_bounce;
 357         int max_bounce;
 358
 359     int max_diffuse_bounce;
 360     int max_glossy_bounce;
 361     int max_transmission_bounce;
 362
 363         /* transparent */
 364     int transparent_min_bounce;
 365     int transparent_max_bounce;
 366         int transparent_shadows;
 367
 368         /* caustics */
 369         int no_caustics;
 370         float blur_caustics;
 371 } KernelIntegrator;
 372
 373 typedef struct KernelBVH {
 374         /* root node */
 375         int root;
 376         int attributes_map_stride;
 377         int pad1, pad2;
 378 } KernelBVH;
 379
 380 typedef struct KernelData {
 381         KernelCamera cam;
 382         KernelFilm film;
 383         KernelBackground background;
 384         KernelSunSky sunsky;
 385         KernelIntegrator integrator;
 386         KernelBVH bvh;
 387 } KernelData;
 388
 389 CCL_NAMESPACE_END
 390
 391 #endif /*  __KERNEL_TYPES_H__ */
 392