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 #include "svm/svm_types.h"
  24
  25 #ifndef __KERNEL_GPU__
  26 #define __KERNEL_CPU__
  27 #endif
  28
  29 CCL_NAMESPACE_BEGIN
  30
  31 /* constants */
  32 #define OBJECT_SIZE             16
  33 #define LIGHT_SIZE                      4
  34 #define FILTER_TABLE_SIZE       256
  35 #define RAMP_TABLE_SIZE         256
  36 #define TIME_INVALID            FLT_MAX
  37
  38 /* device capabilities */
  39 #ifdef __KERNEL_CPU__
  40 #define __KERNEL_SHADING__
  41 #define __KERNEL_ADV_SHADING__
  42 #endif
  43
  44 #ifdef __KERNEL_CUDA__
  45 #define __KERNEL_SHADING__
  46 #if __CUDA_ARCH__ >= 200
  47 #define __KERNEL_ADV_SHADING__
  48 #endif
  49 #endif
  50
  51 #ifdef __KERNEL_OPENCL__
  52 //#define __KERNEL_SHADING__
  53 //#define __KERNEL_ADV_SHADING__
  54 #endif
  55
  56 /* kernel features */
  57 #define __SOBOL__
  58 #define __INSTANCING__
  59 #define __DPDU__
  60 #define __UV__
  61 #define __BACKGROUND__
  62 #define __CAUSTICS_TRICKS__
  63 #define __VISIBILITY_FLAG__
  64 #define __RAY_DIFFERENTIALS__
  65 #define __CAMERA_CLIPPING__
  66 #define __INTERSECTION_REFINE__
  67 #define __CLAMP_SAMPLE__
  68
  69 #ifdef __KERNEL_SHADING__
  70 #define __SVM__
  71 #define __EMISSION__
  72 #define __TEXTURES__
  73 #define __HOLDOUT__
  74 #endif
  75
  76 #ifdef __KERNEL_ADV_SHADING__
  77 #define __MULTI_CLOSURE__
  78 #define __TRANSPARENT_SHADOWS__
  79 #define __PASSES__
  80 #define __BACKGROUND_MIS__
  81 #define __AO__
  82 //#define __MOTION__
  83 #endif
  84
  85 //#define __MULTI_LIGHT__
  86 //#define __OSL__
  87 //#define __SOBOL_FULL_SCREEN__
  88 //#define __MODIFY_TP__
  89 //#define __QBVH__
  90
  91 /* Shader Evaluation */
  92
  93 enum ShaderEvalType {
  94         SHADER_EVAL_DISPLACE,
  95         SHADER_EVAL_BACKGROUND
  96 };
  97
  98 /* Path Tracing
  99  * note we need to keep the u/v pairs at even values */
 100
 101 enum PathTraceDimension {
 102         PRNG_FILTER_U = 0,
 103         PRNG_FILTER_V = 1,
 104         PRNG_LENS_U = 2,
 105         PRNG_LENS_V = 3,
 106 #ifdef __MOTION__
 107         PRNG_TIME = 4,
 108         PRNG_UNUSED = 5,
 109         PRNG_BASE_NUM = 6,
 110 #else
 111         PRNG_BASE_NUM = 4,
 112 #endif
 113
 114         PRNG_BSDF_U = 0,
 115         PRNG_BSDF_V = 1,
 116         PRNG_BSDF = 2,
 117         PRNG_LIGHT = 3,
 118         PRNG_LIGHT_U = 4,
 119         PRNG_LIGHT_V = 5,
 120         PRNG_LIGHT_F = 6,
 121         PRNG_TERMINATE = 7,
 122         PRNG_BOUNCE_NUM = 8
 123 };
 124
 125 /* these flag values correspond exactly to OSL defaults, so be careful not to
 126  * change this, or if you do, set the "raytypes" shading system attribute with
 127  * your own new ray types and bitflag values.
 128  *
 129  * for ray visibility tests in BVH traversal, the upper 20 bits are used for
 130  * layer visibility tests. */
 131
 132 enum PathRayFlag {
 133         PATH_RAY_CAMERA = 1,
 134         PATH_RAY_REFLECT = 2,
 135         PATH_RAY_TRANSMIT = 4,
 136         PATH_RAY_DIFFUSE = 8,
 137         PATH_RAY_GLOSSY = 16,
 138         PATH_RAY_SINGULAR = 32,
 139         PATH_RAY_TRANSPARENT = 64,
 140
 141         PATH_RAY_SHADOW_OPAQUE = 128,
 142         PATH_RAY_SHADOW_TRANSPARENT = 256,
 143         PATH_RAY_SHADOW = (PATH_RAY_SHADOW_OPAQUE|PATH_RAY_SHADOW_TRANSPARENT),
 144
 145         PATH_RAY_MIS_SKIP = 512,
 146
 147         PATH_RAY_ALL = (1|2|4|8|16|32|64|128|256|512),
 148
 149         PATH_RAY_LAYER_SHIFT = (32-20)
 150 };
 151
 152 /* Closure Label */
 153
 154 typedef enum ClosureLabel {
 155         LABEL_NONE = 0,
 156         LABEL_CAMERA = 1,
 157         LABEL_LIGHT = 2,
 158         LABEL_BACKGROUND = 4,
 159         LABEL_TRANSMIT = 8,
 160         LABEL_REFLECT = 16,
 161         LABEL_VOLUME = 32,
 162         LABEL_OBJECT = 64,
 163         LABEL_DIFFUSE = 128,
 164         LABEL_GLOSSY = 256,
 165         LABEL_SINGULAR = 512,
 166         LABEL_TRANSPARENT = 1024,
 167         LABEL_STOP = 2048
 168 } ClosureLabel;
 169
 170 /* Render Passes */
 171
 172 typedef enum PassType {
 173         PASS_NONE = 0,
 174         PASS_COMBINED = 1,
 175         PASS_DEPTH = 2,
 176         PASS_NORMAL = 8,
 177         PASS_UV = 16,
 178         PASS_OBJECT_ID = 32,
 179         PASS_MATERIAL_ID = 64,
 180         PASS_DIFFUSE_COLOR = 128,
 181         PASS_GLOSSY_COLOR = 256,
 182         PASS_TRANSMISSION_COLOR = 512,
 183         PASS_DIFFUSE_INDIRECT = 1024,
 184         PASS_GLOSSY_INDIRECT = 2048,
 185         PASS_TRANSMISSION_INDIRECT = 4096,
 186         PASS_DIFFUSE_DIRECT = 8192,
 187         PASS_GLOSSY_DIRECT = 16384,
 188         PASS_TRANSMISSION_DIRECT = 32768,
 189         PASS_EMISSION = 65536,
 190         PASS_BACKGROUND = 131072,
 191         PASS_AO = 262144,
 192         PASS_SHADOW = 524288,
 193         PASS_MOTION = 1048576,
 194         PASS_MOTION_WEIGHT = 2097152
 195 } PassType;
 196
 197 #define PASS_ALL (~0)
 198
 199 #ifdef __PASSES__
 200
 201 typedef float3 PathThroughput;
 202
 203 typedef struct PathRadiance {
 204         int use_light_pass;
 205
 206         float3 emission;
 207         float3 background;
 208         float3 ao;
 209
 210         float3 indirect;
 211         float3 direct_throughput;
 212         float3 direct_emission;
 213
 214         float3 color_diffuse;
 215         float3 color_glossy;
 216         float3 color_transmission;
 217
 218         float3 direct_diffuse;
 219         float3 direct_glossy;
 220         float3 direct_transmission;
 221
 222         float3 indirect_diffuse;
 223         float3 indirect_glossy;
 224         float3 indirect_transmission;
 225
 226         float4 shadow;
 227 } PathRadiance;
 228
 229 typedef struct BsdfEval {
 230         int use_light_pass;
 231
 232         float3 diffuse;
 233         float3 glossy;
 234         float3 transmission;
 235         float3 transparent;
 236 } BsdfEval;
 237
 238 #else
 239
 240 typedef float3 PathThroughput;
 241 typedef float3 PathRadiance;
 242 typedef float3 BsdfEval;
 243
 244 #endif
 245
 246 /* Shader Flag */
 247
 248 typedef enum ShaderFlag {
 249         SHADER_SMOOTH_NORMAL = (1 << 31),
 250         SHADER_CAST_SHADOW = (1 << 30),
 251         SHADER_AREA_LIGHT = (1 << 29),
 252
 253         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT)
 254 } ShaderFlag;
 255
 256 /* Light Type */
 257
 258 typedef enum LightType {
 259         LIGHT_POINT,
 260         LIGHT_DISTANT,
 261         LIGHT_BACKGROUND,
 262         LIGHT_AREA,
 263         LIGHT_AO
 264 } LightType;
 265
 266 /* Camera Type */
 267
 268 enum CameraType {
 269         CAMERA_PERSPECTIVE,
 270         CAMERA_ORTHOGRAPHIC,
 271         CAMERA_ENVIRONMENT
 272 };
 273
 274 /* Differential */
 275
 276 typedef struct differential3 {
 277         float3 dx;
 278         float3 dy;
 279 } differential3;
 280
 281 typedef struct differential {
 282         float dx;
 283         float dy;
 284 } differential;
 285
 286 /* Ray */
 287
 288 typedef struct Ray {
 289         float3 P;
 290         float3 D;
 291         float t;
 292         float time;
 293
 294 #ifdef __RAY_DIFFERENTIALS__
 295         differential3 dP;
 296         differential3 dD;
 297 #endif
 298 } Ray;
 299
 300 /* Intersection */
 301
 302 typedef struct Intersection {
 303         float t, u, v;
 304         int prim;
 305         int object;
 306 } Intersection;
 307
 308 /* Attributes */
 309
 310 typedef enum AttributeElement {
 311         ATTR_ELEMENT_FACE,
 312         ATTR_ELEMENT_VERTEX,
 313         ATTR_ELEMENT_CORNER,
 314         ATTR_ELEMENT_VALUE,
 315         ATTR_ELEMENT_NONE
 316 } AttributeElement;
 317
 318 typedef enum AttributeStandard {
 319         ATTR_STD_NONE = 0,
 320         ATTR_STD_VERTEX_NORMAL,
 321         ATTR_STD_FACE_NORMAL,
 322         ATTR_STD_UV,
 323         ATTR_STD_GENERATED,
 324         ATTR_STD_POSITION_UNDEFORMED,
 325         ATTR_STD_POSITION_UNDISPLACED,
 326         ATTR_STD_MOTION_PRE,
 327         ATTR_STD_MOTION_POST,
 328         ATTR_STD_NUM,
 329
 330         ATTR_STD_NOT_FOUND = ~0
 331 } AttributeStandard;
 332
 333 /* Closure data */
 334
 335 #define MAX_CLOSURE 8
 336
 337 typedef struct ShaderClosure {
 338         ClosureType type;
 339         float3 weight;
 340
 341 #ifdef __MULTI_CLOSURE__
 342         float sample_weight;
 343 #endif
 344
 345 #ifdef __OSL__
 346         void *prim;
 347 #else
 348         float data0;
 349         float data1;
 350 #endif
 351
 352 } ShaderClosure;
 353
 354 /* Shader Data
 355  *
 356  * Main shader state at a point on the surface or in a volume. All coordinates
 357  * are in world space. */
 358
 359 enum ShaderDataFlag {
 360         /* runtime flags */
 361         SD_BACKFACING = 1,              /* backside of surface? */
 362         SD_EMISSION = 2,                /* have emissive closure? */
 363         SD_BSDF = 4,                    /* have bsdf closure? */
 364         SD_BSDF_HAS_EVAL = 8,   /* have non-singular bsdf closure? */
 365         SD_BSDF_GLOSSY = 16,    /* have glossy bsdf */
 366         SD_HOLDOUT = 32,                /* have holdout closure? */
 367         SD_VOLUME = 64,                 /* have volume closure? */
 368
 369         /* shader flags */
 370         SD_SAMPLE_AS_LIGHT = 128,                       /* direct light sample */
 371         SD_HAS_SURFACE_TRANSPARENT = 256,       /* has surface transparency */
 372         SD_HAS_VOLUME = 512,                            /* has volume shader */
 373         SD_HOMOGENEOUS_VOLUME = 1024,           /* has homogeneous volume */
 374
 375         /* object flags */
 376         SD_HOLDOUT_MASK = 2048,                         /* holdout for camera rays */
 377         SD_OBJECT_MOTION = 4096                         /* has object motion blur */
 378 };
 379
 380 typedef struct ShaderData {
 381         /* position */
 382         float3 P;
 383         /* smooth normal for shading */
 384         float3 N;
 385         /* true geometric normal */
 386         float3 Ng;
 387         /* view/incoming direction */
 388         float3 I;
 389         /* shader id */
 390         int shader;
 391         /* booleans describing shader, see ShaderDataFlag */
 392         int flag;
 393
 394         /* primitive id if there is one, ~0 otherwise */
 395         int prim;
 396         /* parametric coordinates
 397          * - barycentric weights for triangles */
 398         float u, v;
 399         /* object id if there is one, ~0 otherwise */
 400         int object;
 401
 402         /* motion blur sample time */
 403         float time;
 404
 405         /* length of the ray being shaded */
 406         float ray_length;
 407
 408 #ifdef __MOTION__
 409         /* object <-> world space transformations, cached to avoid
 410          * re-interpolating them constantly for shading */
 411         Transform ob_tfm;
 412         Transform ob_itfm;
 413 #endif
 414
 415 #ifdef __RAY_DIFFERENTIALS__
 416         /* differential of P. these are orthogonal to Ng, not N */
 417         differential3 dP;
 418         /* differential of I */
 419         differential3 dI;
 420         /* differential of u, v */
 421         differential du;
 422         differential dv;
 423 #endif
 424 #ifdef __DPDU__
 425         /* differential of P w.r.t. parametric coordinates. note that dPdu is
 426          * not readily suitable as a tangent for shading on triangles. */
 427         float3 dPdu, dPdv;
 428 #endif
 429
 430 #ifdef __MULTI_CLOSURE__
 431         /* Closure data, we store a fixed array of closures */
 432         ShaderClosure closure[MAX_CLOSURE];
 433         int num_closure;
 434         float randb_closure;
 435 #else
 436         /* Closure data, with a single sampled closure for low memory usage */
 437         ShaderClosure closure;
 438 #endif
 439
 440 #ifdef __OSL__
 441         /* OSL context */
 442         void *osl_ctx;
 443 #endif
 444 } ShaderData;
 445
 446 /* Constrant Kernel Data
 447  *
 448  * These structs are passed from CPU to various devices, and the struct layout
 449  * must match exactly. Structs are padded to ensure 16 byte alignment, and we
 450  * do not use float3 because its size may not be the same on all devices. */
 451
 452 typedef struct KernelCamera {
 453         /* type */
 454         int type;
 455         int pad1, pad2, pad3;
 456
 457         /* matrices */
 458         Transform cameratoworld;
 459         Transform rastertocamera;
 460
 461         /* differentials */
 462         float4 dx;
 463         float4 dy;
 464
 465         /* depth of field */
 466         float aperturesize;
 467         float blades;
 468         float bladesrotation;
 469         float focaldistance;
 470
 471         /* motion blur */
 472         float shuttertime;
 473         int have_motion;
 474
 475         /* clipping */
 476         float nearclip;
 477         float cliplength;
 478
 479         /* more matrices */
 480         Transform screentoworld;
 481         Transform rastertoworld;
 482         Transform ndctoworld;
 483         Transform worldtoscreen;
 484         Transform worldtoraster;
 485         Transform worldtondc;
 486         Transform worldtocamera;
 487
 488         MotionTransform motion;
 489 } KernelCamera;
 490
 491 typedef struct KernelFilm {
 492         float exposure;
 493         int pass_flag;
 494         int pass_stride;
 495         int use_light_pass;
 496
 497         int pass_combined;
 498         int pass_depth;
 499         int pass_normal;
 500         int pass_motion;
 501
 502         int pass_motion_weight;
 503         int pass_uv;
 504         int pass_object_id;
 505         int pass_material_id;
 506
 507         int pass_diffuse_color;
 508         int pass_glossy_color;
 509         int pass_transmission_color;
 510         int pass_diffuse_indirect;
 511
 512         int pass_glossy_indirect;
 513         int pass_transmission_indirect;
 514         int pass_diffuse_direct;
 515         int pass_glossy_direct;
 516
 517         int pass_transmission_direct;
 518         int pass_emission;
 519         int pass_background;
 520         int pass_ao;
 521
 522         int pass_shadow;
 523         int pass_pad1;
 524         int pass_pad2;
 525         int pass_pad3;
 526 } KernelFilm;
 527
 528 typedef struct KernelBackground {
 529         /* only shader index */
 530         int shader;
 531         int transparent;
 532
 533         /* ambient occlusion */
 534         float ao_factor;
 535         float ao_distance;
 536 } KernelBackground;
 537
 538 typedef struct KernelSunSky {
 539         /* sun direction in spherical and cartesian */
 540         float theta, phi, pad3, pad4;
 541
 542         /* perez function parameters */
 543         float zenith_Y, zenith_x, zenith_y, pad2;
 544         float perez_Y[5], perez_x[5], perez_y[5];
 545         float pad5;
 546 } KernelSunSky;
 547
 548 typedef struct KernelIntegrator {
 549         /* emission */
 550         int use_direct_light;
 551         int use_ambient_occlusion;
 552         int num_distribution;
 553         int num_all_lights;
 554         float pdf_triangles;
 555         float pdf_lights;
 556         int pdf_background_res;
 557
 558         /* bounces */
 559         int min_bounce;
 560         int max_bounce;
 561
 562         int max_diffuse_bounce;
 563         int max_glossy_bounce;
 564         int max_transmission_bounce;
 565
 566         /* transparent */
 567         int transparent_min_bounce;
 568         int transparent_max_bounce;
 569         int transparent_shadows;
 570
 571         /* caustics */
 572         int no_caustics;
 573         float filter_glossy;
 574
 575         /* seed */
 576         int seed;
 577
 578         /* render layer */
 579         int layer_flag;
 580
 581         /* clamp */
 582         float sample_clamp;
 583 } KernelIntegrator;
 584
 585 typedef struct KernelBVH {
 586         /* root node */
 587         int root;
 588         int attributes_map_stride;
 589         int pad1, pad2;
 590 } KernelBVH;
 591
 592 typedef struct KernelData {
 593         KernelCamera cam;
 594         KernelFilm film;
 595         KernelBackground background;
 596         KernelSunSky sunsky;
 597         KernelIntegrator integrator;
 598         KernelBVH bvh;
 599 } KernelData;
 600
 601 CCL_NAMESPACE_END
 602
 603 #endif /*  __KERNEL_TYPES_H__ */
 604