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