Cycles: add "density", "flame" and "color" attributes for smoke domains.
[blender.git] / intern / cycles / kernel / kernel_types.h
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License
15  */
16
17 #ifndef __KERNEL_TYPES_H__
18 #define __KERNEL_TYPES_H__
19
20 #include "kernel_math.h"
21 #include "svm/svm_types.h"
22
23 #ifndef __KERNEL_GPU__
24 #define __KERNEL_CPU__
25 #endif
26
27 CCL_NAMESPACE_BEGIN
28
29 /* constants */
30 #define OBJECT_SIZE             11
31 #define OBJECT_VECTOR_SIZE      6
32 #define LIGHT_SIZE                      4
33 #define FILTER_TABLE_SIZE       256
34 #define RAMP_TABLE_SIZE         256
35 #define PARTICLE_SIZE           5
36 #define TIME_INVALID            FLT_MAX
37
38 #define BSSRDF_MIN_RADIUS                       1e-8f
39 #define BSSRDF_MAX_HITS                         4
40
41 #define BB_DRAPPER                              800.0f
42 #define BB_MAX_TABLE_RANGE              12000.0f
43 #define BB_TABLE_XPOWER                 1.5f
44 #define BB_TABLE_YPOWER                 5.0f
45 #define BB_TABLE_SPACING                2.0f
46
47 #define TEX_NUM_FLOAT_IMAGES    5
48
49 #define SHADER_NONE                             (~0)
50 #define OBJECT_NONE                             (~0)
51 #define PRIM_NONE                               (~0)
52 #define LAMP_NONE                               (~0)
53
54 #define VOLUME_STACK_SIZE               16
55
56 /* device capabilities */
57 #ifdef __KERNEL_CPU__
58 #define __KERNEL_SHADING__
59 #define __KERNEL_ADV_SHADING__
60 #define __BRANCHED_PATH__
61 #ifdef WITH_OSL
62 #define __OSL__
63 #endif
64 #define __SUBSURFACE__
65 #define __CMJ__
66 #define __VOLUME__
67 #endif
68
69 #ifdef __KERNEL_CUDA__
70 #define __KERNEL_SHADING__
71 #define __KERNEL_ADV_SHADING__
72 #if __CUDA_ARCH__ != 300
73 #define __BRANCHED_PATH__
74 #endif
75 //#define __VOLUME__
76 #endif
77
78 #ifdef __KERNEL_OPENCL__
79
80 /* keep __KERNEL_ADV_SHADING__ in sync with opencl_kernel_use_advanced_shading! */
81
82 #ifdef __KERNEL_OPENCL_NVIDIA__
83 #define __KERNEL_SHADING__
84 #define __KERNEL_ADV_SHADING__
85 #endif
86
87 #ifdef __KERNEL_OPENCL_APPLE__
88 #define __KERNEL_SHADING__
89 //#define __KERNEL_ADV_SHADING__
90 #endif
91
92 #ifdef __KERNEL_OPENCL_AMD__
93 #define __SVM__
94 #define __EMISSION__
95 #define __IMAGE_TEXTURES__
96 #define __PROCEDURAL_TEXTURES__
97 #define __EXTRA_NODES__
98 #define __HOLDOUT__
99 #define __NORMAL_MAP__
100 //#define __BACKGROUND_MIS__
101 //#define __LAMP_MIS__
102 //#define __AO__
103 //#define __ANISOTROPIC__
104 //#define __CAMERA_MOTION__
105 //#define __OBJECT_MOTION__
106 //#define __HAIR__
107 //#define __MULTI_CLOSURE__
108 //#define __TRANSPARENT_SHADOWS__
109 //#define __PASSES__
110 #endif
111
112 #ifdef __KERNEL_OPENCL_INTEL_CPU__
113 #define __KERNEL_SHADING__
114 #define __KERNEL_ADV_SHADING__
115 #endif
116
117 #endif
118
119 /* kernel features */
120 #define __SOBOL__
121 #define __INSTANCING__
122 #define __DPDU__
123 #define __UV__
124 #define __BACKGROUND__
125 #define __CAUSTICS_TRICKS__
126 #define __VISIBILITY_FLAG__
127 #define __RAY_DIFFERENTIALS__
128 #define __CAMERA_CLIPPING__
129 #define __INTERSECTION_REFINE__
130 #define __CLAMP_SAMPLE__
131
132 #ifdef __KERNEL_SHADING__
133 #define __SVM__
134 #define __EMISSION__
135 #define __PROCEDURAL_TEXTURES__
136 #define __IMAGE_TEXTURES__
137 #define __EXTRA_NODES__
138 #define __HOLDOUT__
139 #define __NORMAL_MAP__
140 #endif
141
142 #ifdef __KERNEL_ADV_SHADING__
143 #define __MULTI_CLOSURE__
144 #define __TRANSPARENT_SHADOWS__
145 #define __PASSES__
146 #define __BACKGROUND_MIS__
147 #define __LAMP_MIS__
148 #define __AO__
149 #define __ANISOTROPIC__
150 #define __CAMERA_MOTION__
151 #define __OBJECT_MOTION__
152 #define __HAIR__
153 #endif
154
155 /* Sanity check */
156
157 #if defined(__KERNEL_OPENCL_NEED_ADVANCED_SHADING__) && !defined(__MULTI_CLOSURE__)
158 #error "OpenCL: mismatch between advanced shading flags in device_opencl.cpp and kernel_types.h"
159 #endif
160
161 /* Random Numbers */
162
163 typedef uint RNG;
164
165 /* Shader Evaluation */
166
167 typedef enum ShaderEvalType {
168         SHADER_EVAL_DISPLACE,
169         SHADER_EVAL_BACKGROUND
170 } ShaderEvalType;
171
172 /* Path Tracing
173  * note we need to keep the u/v pairs at even values */
174
175 enum PathTraceDimension {
176         PRNG_FILTER_U = 0,
177         PRNG_FILTER_V = 1,
178         PRNG_LENS_U = 2,
179         PRNG_LENS_V = 3,
180 #ifdef __CAMERA_MOTION__
181         PRNG_TIME = 4,
182         PRNG_UNUSED_0 = 5,
183         PRNG_UNUSED_1 = 6,      /* for some reason (6, 7) is a bad sobol pattern */
184         PRNG_UNUSED_2 = 7,  /* with a low number of samples (< 64) */
185         PRNG_BASE_NUM = 8,
186 #else
187         PRNG_BASE_NUM = 4,
188 #endif
189
190         PRNG_BSDF_U = 0,
191         PRNG_BSDF_V = 1,
192         PRNG_BSDF = 2,
193         PRNG_LIGHT = 3,
194         PRNG_LIGHT_U = 4,
195         PRNG_LIGHT_V = 5,
196         PRNG_LIGHT_F = 6,
197         PRNG_TERMINATE = 7,
198
199 #ifdef __VOLUME__
200         PRNG_PHASE_U = 8,
201         PRNG_PHASE_V = 9,
202         PRNG_PHASE = 10,
203         PRNG_SCATTER_DISTANCE = 11,
204         PRNG_BOUNCE_NUM = 12,
205 #else
206         PRNG_BOUNCE_NUM = 8,
207 #endif
208 };
209
210 enum SamplingPattern {
211         SAMPLING_PATTERN_SOBOL = 0,
212         SAMPLING_PATTERN_CMJ = 1
213 };
214
215 /* these flags values correspond to raytypes in osl.cpp, so keep them in sync!
216  *
217  * for ray visibility tests in BVH traversal, the upper 20 bits are used for
218  * layer visibility tests. */
219
220 enum PathRayFlag {
221         PATH_RAY_CAMERA = 1,
222         PATH_RAY_REFLECT = 2,
223         PATH_RAY_TRANSMIT = 4,
224         PATH_RAY_DIFFUSE = 8,
225         PATH_RAY_GLOSSY = 16,
226         PATH_RAY_SINGULAR = 32,
227         PATH_RAY_TRANSPARENT = 64,
228
229         PATH_RAY_SHADOW_OPAQUE = 128,
230         PATH_RAY_SHADOW_TRANSPARENT = 256,
231         PATH_RAY_SHADOW = (PATH_RAY_SHADOW_OPAQUE|PATH_RAY_SHADOW_TRANSPARENT),
232
233         PATH_RAY_CURVE = 512, /* visibility flag to define curve segments*/
234
235         /* note that these can use maximum 12 bits, the other are for layers */
236         PATH_RAY_ALL_VISIBILITY = (1|2|4|8|16|32|64|128|256|512),
237
238         PATH_RAY_MIS_SKIP = 1024,
239         PATH_RAY_DIFFUSE_ANCESTOR = 2048,
240         PATH_RAY_GLOSSY_ANCESTOR = 4096,
241         PATH_RAY_BSSRDF_ANCESTOR = 8192,
242         PATH_RAY_SINGLE_PASS_DONE = 16384,
243         PATH_RAY_VOLUME_SCATTER = 32768,
244
245         /* we need layer member flags to be the 20 upper bits */
246         PATH_RAY_LAYER_SHIFT = (32-20)
247 };
248
249 /* Closure Label */
250
251 typedef enum ClosureLabel {
252         LABEL_NONE = 0,
253         LABEL_TRANSMIT = 1,
254         LABEL_REFLECT = 2,
255         LABEL_DIFFUSE = 4,
256         LABEL_GLOSSY = 8,
257         LABEL_SINGULAR = 16,
258         LABEL_TRANSPARENT = 32,
259         LABEL_VOLUME_SCATTER = 64,
260 } ClosureLabel;
261
262 /* Render Passes */
263
264 typedef enum PassType {
265         PASS_NONE = 0,
266         PASS_COMBINED = 1,
267         PASS_DEPTH = 2,
268         PASS_NORMAL = 4,
269         PASS_UV = 8,
270         PASS_OBJECT_ID = 16,
271         PASS_MATERIAL_ID = 32,
272         PASS_DIFFUSE_COLOR = 64,
273         PASS_GLOSSY_COLOR = 128,
274         PASS_TRANSMISSION_COLOR = 256,
275         PASS_DIFFUSE_INDIRECT = 512,
276         PASS_GLOSSY_INDIRECT = 1024,
277         PASS_TRANSMISSION_INDIRECT = 2048,
278         PASS_DIFFUSE_DIRECT = 4096,
279         PASS_GLOSSY_DIRECT = 8192,
280         PASS_TRANSMISSION_DIRECT = 16384,
281         PASS_EMISSION = 32768,
282         PASS_BACKGROUND = 65536,
283         PASS_AO = 131072,
284         PASS_SHADOW = 262144,
285         PASS_MOTION = 524288,
286         PASS_MOTION_WEIGHT = 1048576,
287         PASS_MIST = 2097152,
288         PASS_SUBSURFACE_DIRECT = 4194304,
289         PASS_SUBSURFACE_INDIRECT = 8388608,
290         PASS_SUBSURFACE_COLOR = 16777216
291 } PassType;
292
293 #define PASS_ALL (~0)
294
295 #ifdef __PASSES__
296
297 typedef struct PathRadiance {
298         int use_light_pass;
299
300         float3 emission;
301         float3 background;
302         float3 ao;
303
304         float3 indirect;
305         float3 direct_throughput;
306         float3 direct_emission;
307
308         float3 color_diffuse;
309         float3 color_glossy;
310         float3 color_transmission;
311         float3 color_subsurface;
312
313         float3 direct_diffuse;
314         float3 direct_glossy;
315         float3 direct_transmission;
316         float3 direct_subsurface;
317
318         float3 indirect_diffuse;
319         float3 indirect_glossy;
320         float3 indirect_transmission;
321         float3 indirect_subsurface;
322
323         float3 path_diffuse;
324         float3 path_glossy;
325         float3 path_transmission;
326         float3 path_subsurface;
327
328         float4 shadow;
329         float mist;
330 } PathRadiance;
331
332 typedef struct BsdfEval {
333         int use_light_pass;
334
335         float3 diffuse;
336         float3 glossy;
337         float3 transmission;
338         float3 transparent;
339         float3 subsurface;
340 } BsdfEval;
341
342 #else
343
344 typedef float3 PathRadiance;
345 typedef float3 BsdfEval;
346
347 #endif
348
349 /* Shader Flag */
350
351 typedef enum ShaderFlag {
352         SHADER_SMOOTH_NORMAL = (1 << 31),
353         SHADER_CAST_SHADOW = (1 << 30),
354         SHADER_AREA_LIGHT = (1 << 29),
355         SHADER_USE_MIS = (1 << 28),
356         SHADER_EXCLUDE_DIFFUSE = (1 << 27),
357         SHADER_EXCLUDE_GLOSSY = (1 << 26),
358         SHADER_EXCLUDE_TRANSMIT = (1 << 25),
359         SHADER_EXCLUDE_CAMERA = (1 << 24),
360         SHADER_EXCLUDE_ANY = (SHADER_EXCLUDE_DIFFUSE|SHADER_EXCLUDE_GLOSSY|SHADER_EXCLUDE_TRANSMIT|SHADER_EXCLUDE_CAMERA),
361
362         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT|SHADER_USE_MIS|SHADER_EXCLUDE_ANY)
363 } ShaderFlag;
364
365 /* Light Type */
366
367 typedef enum LightType {
368         LIGHT_POINT,
369         LIGHT_DISTANT,
370         LIGHT_BACKGROUND,
371         LIGHT_AREA,
372         LIGHT_AO,
373         LIGHT_SPOT,
374         LIGHT_TRIANGLE,
375         LIGHT_STRAND
376 } LightType;
377
378 /* Camera Type */
379
380 enum CameraType {
381         CAMERA_PERSPECTIVE,
382         CAMERA_ORTHOGRAPHIC,
383         CAMERA_PANORAMA
384 };
385
386 /* Panorama Type */
387
388 enum PanoramaType {
389         PANORAMA_EQUIRECTANGULAR,
390         PANORAMA_FISHEYE_EQUIDISTANT,
391         PANORAMA_FISHEYE_EQUISOLID
392 };
393
394 /* Differential */
395
396 typedef struct differential3 {
397         float3 dx;
398         float3 dy;
399 } differential3;
400
401 typedef struct differential {
402         float dx;
403         float dy;
404 } differential;
405
406 /* Ray */
407
408 typedef struct Ray {
409         float3 P;               /* origin */
410         float3 D;               /* direction */
411         float t;                /* length of the ray */
412         float time;             /* time (for motion blur) */
413
414 #ifdef __RAY_DIFFERENTIALS__
415         differential3 dP;
416         differential3 dD;
417 #endif
418 } Ray;
419
420 /* Intersection */
421
422 typedef struct Intersection {
423         float t, u, v;
424         int prim;
425         int object;
426         int type;
427 } Intersection;
428
429 /* Primitives */
430
431 typedef enum PrimitiveType {
432         PRIMITIVE_NONE = 0,
433         PRIMITIVE_TRIANGLE = 1,
434         PRIMITIVE_MOTION_TRIANGLE = 2,
435         PRIMITIVE_CURVE = 4,
436         PRIMITIVE_MOTION_CURVE = 8,
437
438         PRIMITIVE_ALL_TRIANGLE = (PRIMITIVE_TRIANGLE|PRIMITIVE_MOTION_TRIANGLE),
439         PRIMITIVE_ALL_CURVE = (PRIMITIVE_CURVE|PRIMITIVE_MOTION_CURVE),
440         PRIMITIVE_ALL_MOTION = (PRIMITIVE_MOTION_TRIANGLE|PRIMITIVE_MOTION_CURVE),
441         PRIMITIVE_ALL = (PRIMITIVE_ALL_TRIANGLE|PRIMITIVE_ALL_CURVE)
442 } PrimitiveType;
443
444 #define PRIMITIVE_PACK_SEGMENT(type, segment) ((segment << 16) | type)
445 #define PRIMITIVE_UNPACK_SEGMENT(type) (type >> 16)
446
447 /* Attributes */
448
449 #define ATTR_PRIM_TYPES         2
450 #define ATTR_PRIM_CURVE         1
451
452 typedef enum AttributeElement {
453         ATTR_ELEMENT_NONE,
454         ATTR_ELEMENT_OBJECT,
455         ATTR_ELEMENT_MESH,
456         ATTR_ELEMENT_FACE,
457         ATTR_ELEMENT_VERTEX,
458         ATTR_ELEMENT_VERTEX_MOTION,
459         ATTR_ELEMENT_CORNER,
460         ATTR_ELEMENT_CURVE,
461         ATTR_ELEMENT_CURVE_KEY,
462         ATTR_ELEMENT_CURVE_KEY_MOTION,
463         ATTR_ELEMENT_VOXEL
464 } AttributeElement;
465
466 typedef enum AttributeStandard {
467         ATTR_STD_NONE = 0,
468         ATTR_STD_VERTEX_NORMAL,
469         ATTR_STD_FACE_NORMAL,
470         ATTR_STD_UV,
471         ATTR_STD_UV_TANGENT,
472         ATTR_STD_UV_TANGENT_SIGN,
473         ATTR_STD_GENERATED,
474         ATTR_STD_GENERATED_TRANSFORM,
475         ATTR_STD_POSITION_UNDEFORMED,
476         ATTR_STD_POSITION_UNDISPLACED,
477         ATTR_STD_MOTION_VERTEX_POSITION,
478         ATTR_STD_MOTION_VERTEX_NORMAL,
479         ATTR_STD_PARTICLE,
480         ATTR_STD_CURVE_INTERCEPT,
481         ATTR_STD_PTEX_FACE_ID,
482         ATTR_STD_PTEX_UV,
483         ATTR_STD_VOLUME_DENSITY,
484         ATTR_STD_VOLUME_COLOR,
485         ATTR_STD_VOLUME_FLAME,
486         ATTR_STD_VOLUME_HEAT,
487         ATTR_STD_VOLUME_VELOCITY,
488         ATTR_STD_NUM,
489
490         ATTR_STD_NOT_FOUND = ~0
491 } AttributeStandard;
492
493 /* Closure data */
494
495 #define MAX_CLOSURE 64
496
497 typedef struct ShaderClosure {
498         ClosureType type;
499         float3 weight;
500
501 #ifdef __MULTI_CLOSURE__
502         float sample_weight;
503 #endif
504
505         float data0;
506         float data1;
507
508         float3 N;
509 #if defined(__ANISOTROPIC__) || defined(__SUBSURFACE__) || defined(__HAIR__)
510         float3 T;
511 #endif
512
513 #ifdef __HAIR__
514         float offset;
515 #endif
516
517 #ifdef __OSL__
518         void *prim;
519 #endif
520 } ShaderClosure;
521
522 /* Shader Context
523  *
524  * For OSL we recycle a fixed number of contexts for speed */
525
526 typedef enum ShaderContext {
527         SHADER_CONTEXT_MAIN = 0,
528         SHADER_CONTEXT_INDIRECT = 1,
529         SHADER_CONTEXT_EMISSION = 2,
530         SHADER_CONTEXT_SHADOW = 3,
531         SHADER_CONTEXT_SSS = 4,
532         SHADER_CONTEXT_VOLUME = 5,
533         SHADER_CONTEXT_NUM = 6
534 } ShaderContext;
535
536 /* Shader Data
537  *
538  * Main shader state at a point on the surface or in a volume. All coordinates
539  * are in world space. */
540
541 enum ShaderDataFlag {
542         /* runtime flags */
543         SD_BACKFACING = 1,              /* backside of surface? */
544         SD_EMISSION = 2,                /* have emissive closure? */
545         SD_BSDF = 4,                    /* have bsdf closure? */
546         SD_BSDF_HAS_EVAL = 8,   /* have non-singular bsdf closure? */
547         SD_PHASE_HAS_EVAL = 8,  /* have non-singular phase closure? */
548         SD_BSDF_GLOSSY = 16,    /* have glossy bsdf */
549         SD_BSSRDF = 32,                 /* have bssrdf */
550         SD_HOLDOUT = 64,                /* have holdout closure? */
551         SD_ABSORPTION = 128,    /* have volume absorption closure? */
552         SD_SCATTER = 256,               /* have volume phase closure? */
553         SD_AO = 512,                    /* have ao closure? */
554         SD_TRANSPARENT = 1024,  /* have transparent closure? */
555
556         SD_CLOSURE_FLAGS = (SD_EMISSION|SD_BSDF|SD_BSDF_HAS_EVAL|SD_BSDF_GLOSSY|SD_BSSRDF|SD_HOLDOUT|SD_ABSORPTION|SD_SCATTER|SD_AO),
557
558         /* shader flags */
559         SD_USE_MIS = 2048,                                      /* direct light sample */
560         SD_HAS_TRANSPARENT_SHADOW = 4096,       /* has transparent shadow */
561         SD_HAS_VOLUME = 8192,                           /* has volume shader */
562         SD_HAS_ONLY_VOLUME = 16384,                     /* has only volume shader, no surface */
563         SD_HETEROGENEOUS_VOLUME = 32768,        /* has heterogeneous volume */
564         SD_HAS_BSSRDF_BUMP = 65536,                     /* bssrdf normal uses bump */
565
566         SD_SHADER_FLAGS = (SD_USE_MIS|SD_HAS_TRANSPARENT_SHADOW|SD_HAS_VOLUME|SD_HAS_ONLY_VOLUME|SD_HETEROGENEOUS_VOLUME|SD_HAS_BSSRDF_BUMP),
567
568         /* object flags */
569         SD_HOLDOUT_MASK = 131072,                       /* holdout for camera rays */
570         SD_OBJECT_MOTION = 262144,                      /* has object motion blur */
571         SD_TRANSFORM_APPLIED = 524288,          /* vertices have transform applied */
572
573         SD_OBJECT_FLAGS = (SD_HOLDOUT_MASK|SD_OBJECT_MOTION|SD_TRANSFORM_APPLIED)
574 };
575
576 struct KernelGlobals;
577
578 typedef struct ShaderData {
579         /* position */
580         float3 P;
581         /* smooth normal for shading */
582         float3 N;
583         /* true geometric normal */
584         float3 Ng;
585         /* view/incoming direction */
586         float3 I;
587         /* shader id */
588         int shader;
589         /* booleans describing shader, see ShaderDataFlag */
590         int flag;
591
592         /* primitive id if there is one, ~0 otherwise */
593         int prim;
594
595         /* combined type and curve segment for hair */
596         int type;
597
598         /* parametric coordinates
599          * - barycentric weights for triangles */
600         float u, v;
601         /* object id if there is one, ~0 otherwise */
602         int object;
603
604         /* motion blur sample time */
605         float time;
606         
607         /* length of the ray being shaded */
608         float ray_length;
609         
610         /* ray bounce depth */
611         int ray_depth;
612
613 #ifdef __RAY_DIFFERENTIALS__
614         /* differential of P. these are orthogonal to Ng, not N */
615         differential3 dP;
616         /* differential of I */
617         differential3 dI;
618         /* differential of u, v */
619         differential du;
620         differential dv;
621 #endif
622 #ifdef __DPDU__
623         /* differential of P w.r.t. parametric coordinates. note that dPdu is
624          * not readily suitable as a tangent for shading on triangles. */
625         float3 dPdu, dPdv;
626 #endif
627
628 #ifdef __OBJECT_MOTION__
629         /* object <-> world space transformations, cached to avoid
630          * re-interpolating them constantly for shading */
631         Transform ob_tfm;
632         Transform ob_itfm;
633 #endif
634
635 #ifdef __MULTI_CLOSURE__
636         /* Closure data, we store a fixed array of closures */
637         ShaderClosure closure[MAX_CLOSURE];
638         int num_closure;
639         float randb_closure;
640 #else
641         /* Closure data, with a single sampled closure for low memory usage */
642         ShaderClosure closure;
643 #endif
644
645         /* ray start position, only set for backgrounds */
646         float3 ray_P;
647         differential3 ray_dP;
648
649 #ifdef __OSL__
650         struct KernelGlobals *osl_globals;
651 #endif
652 } ShaderData;
653
654 /* Path State */
655
656 #ifdef __VOLUME__
657 typedef struct VolumeStack {
658         int object;
659         int shader;
660 } VolumeStack;
661 #endif
662
663 typedef struct PathState {
664         /* see enum PathRayFlag */
665         int flag;          
666
667         /* random number generator state */
668         int rng_offset;    /* dimension offset */
669         int sample;        /* path sample number */
670         int num_samples;   /* total number of times this path will be sampled */
671
672         /* bounce counting */
673         int bounce;
674         int diffuse_bounce;
675         int glossy_bounce;
676         int transmission_bounce;
677         int transparent_bounce;
678
679         /* multiple importance sampling */
680         float min_ray_pdf; /* smallest bounce pdf over entire path up to now */
681         float ray_pdf;     /* last bounce pdf */
682 #ifdef __LAMP_MIS__
683         float ray_t;       /* accumulated distance through transparent surfaces */
684 #endif
685
686         /* volume rendering */
687 #ifdef __VOLUME__
688         int volume_bounce;
689         RNG rng_congruential;
690         VolumeStack volume_stack[VOLUME_STACK_SIZE];
691 #endif
692 } PathState;
693
694 /* Constant Kernel Data
695  *
696  * These structs are passed from CPU to various devices, and the struct layout
697  * must match exactly. Structs are padded to ensure 16 byte alignment, and we
698  * do not use float3 because its size may not be the same on all devices. */
699
700 typedef struct KernelCamera {
701         /* type */
702         int type;
703
704         /* panorama */
705         int panorama_type;
706         float fisheye_fov;
707         float fisheye_lens;
708
709         /* matrices */
710         Transform cameratoworld;
711         Transform rastertocamera;
712
713         /* differentials */
714         float4 dx;
715         float4 dy;
716
717         /* depth of field */
718         float aperturesize;
719         float blades;
720         float bladesrotation;
721         float focaldistance;
722
723         /* motion blur */
724         float shuttertime;
725         int have_motion;
726
727         /* clipping */
728         float nearclip;
729         float cliplength;
730
731         /* sensor size */
732         float sensorwidth;
733         float sensorheight;
734
735         /* render size */
736         float width, height;
737         int resolution;
738         int pad1;
739         int pad2;
740         int pad3;
741
742         /* more matrices */
743         Transform screentoworld;
744         Transform rastertoworld;
745         /* work around cuda sm 2.0 crash, this seems to
746          * cross some limit in combination with motion 
747          * Transform ndctoworld; */
748         Transform worldtoscreen;
749         Transform worldtoraster;
750         Transform worldtondc;
751         Transform worldtocamera;
752
753         MotionTransform motion;
754 } KernelCamera;
755
756 typedef struct KernelFilm {
757         float exposure;
758         int pass_flag;
759         int pass_stride;
760         int use_light_pass;
761
762         int pass_combined;
763         int pass_depth;
764         int pass_normal;
765         int pass_motion;
766
767         int pass_motion_weight;
768         int pass_uv;
769         int pass_object_id;
770         int pass_material_id;
771
772         int pass_diffuse_color;
773         int pass_glossy_color;
774         int pass_transmission_color;
775         int pass_subsurface_color;
776         
777         int pass_diffuse_indirect;
778         int pass_glossy_indirect;
779         int pass_transmission_indirect;
780         int pass_subsurface_indirect;
781         
782         int pass_diffuse_direct;
783         int pass_glossy_direct;
784         int pass_transmission_direct;
785         int pass_subsurface_direct;
786         
787         int pass_emission;
788         int pass_background;
789         int pass_ao;
790         float pass_alpha_threshold;
791
792         int pass_shadow;
793         float pass_shadow_scale;
794         int filter_table_offset;
795         int pass_pad2;
796
797         int pass_mist;
798         float mist_start;
799         float mist_inv_depth;
800         float mist_falloff;
801 } KernelFilm;
802
803 typedef struct KernelBackground {
804         /* only shader index */
805         int surface_shader;
806         int volume_shader;
807         int transparent;
808         int pad;
809
810         /* ambient occlusion */
811         float ao_factor;
812         float ao_distance;
813         float ao_pad1, ao_pad2;
814 } KernelBackground;
815
816 typedef struct KernelIntegrator {
817         /* emission */
818         int use_direct_light;
819         int use_ambient_occlusion;
820         int num_distribution;
821         int num_all_lights;
822         float pdf_triangles;
823         float pdf_lights;
824         float inv_pdf_lights;
825         int pdf_background_res;
826
827         /* bounces */
828         int min_bounce;
829         int max_bounce;
830
831         int max_diffuse_bounce;
832         int max_glossy_bounce;
833         int max_transmission_bounce;
834         int max_volume_bounce;
835
836         /* transparent */
837         int transparent_min_bounce;
838         int transparent_max_bounce;
839         int transparent_shadows;
840
841         /* caustics */
842         int no_caustics;
843         float filter_glossy;
844
845         /* seed */
846         int seed;
847
848         /* render layer */
849         int layer_flag;
850
851         /* clamp */
852         float sample_clamp_direct;
853         float sample_clamp_indirect;
854
855         /* branched path */
856         int branched;
857         int diffuse_samples;
858         int glossy_samples;
859         int transmission_samples;
860         int ao_samples;
861         int mesh_light_samples;
862         int subsurface_samples;
863         int sample_all_lights_direct;
864         int sample_all_lights_indirect;
865
866         /* mis */
867         int use_lamp_mis;
868
869         /* sampler */
870         int sampling_pattern;
871         int aa_samples;
872
873         /* volume render */
874         int volume_homogeneous_sampling;
875         int use_volumes;
876         int volume_max_steps;
877         float volume_step_size;
878         int volume_samples;
879 } KernelIntegrator;
880
881 typedef struct KernelBVH {
882         /* root node */
883         int root;
884         int attributes_map_stride;
885         int have_motion;
886         int have_curves;
887         int have_instancing;
888
889         int pad1, pad2, pad3;
890 } KernelBVH;
891
892 typedef enum CurveFlag {
893         /* runtime flags */
894         CURVE_KN_BACKFACING = 1,                                /* backside of cylinder? */
895         CURVE_KN_ENCLOSEFILTER = 2,                             /* don't consider strands surrounding start point? */
896         CURVE_KN_INTERPOLATE = 4,                               /* render as a curve? */
897         CURVE_KN_ACCURATE = 8,                                  /* use accurate intersections test? */
898         CURVE_KN_INTERSECTCORRECTION = 16,              /* correct for width after determing closest midpoint? */
899         CURVE_KN_TRUETANGENTGNORMAL = 32,               /* use tangent normal for geometry? */
900         CURVE_KN_RIBBONS = 64,                                  /* use flat curve ribbons */
901 } CurveFlag;
902
903 typedef struct KernelCurves {
904         /* strand intersect and normal parameters - many can be changed to flags */
905         int curveflags;
906         int subdivisions;
907
908         float minimum_width;
909         float maximum_width;
910 } KernelCurves;
911
912 typedef struct KernelBlackbody {
913         int table_offset;
914         int pad1, pad2, pad3;
915 } KernelBlackbody;
916
917
918 typedef struct KernelData {
919         KernelCamera cam;
920         KernelFilm film;
921         KernelBackground background;
922         KernelIntegrator integrator;
923         KernelBVH bvh;
924         KernelCurves curve;
925         KernelBlackbody blackbody;
926 } KernelData;
927
928 CCL_NAMESPACE_END
929
930 #endif /*  __KERNEL_TYPES_H__ */
931