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