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