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