Cycles: better path termination for transparency.
[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/kernel_math.h"
21 #include "kernel/svm/svm_types.h"
22 #include "util/util_static_assert.h"
23
24 #ifndef __KERNEL_GPU__
25 #  define __KERNEL_CPU__
26 #endif
27
28 /* TODO(sergey): This is only to make it possible to include this header
29  * from outside of the kernel. but this could be done somewhat cleaner?
30  */
31 #ifndef ccl_addr_space
32 #  define ccl_addr_space
33 #endif
34
35 CCL_NAMESPACE_BEGIN
36
37 /* Constants */
38 #define OBJECT_SIZE             16
39 #define OBJECT_VECTOR_SIZE      6
40 #define LIGHT_SIZE              11
41 #define FILTER_TABLE_SIZE       1024
42 #define RAMP_TABLE_SIZE         256
43 #define SHUTTER_TABLE_SIZE              256
44 #define PARTICLE_SIZE           5
45 #define SHADER_SIZE             5
46
47 #define BSSRDF_MIN_RADIUS                       1e-8f
48 #define BSSRDF_MAX_HITS                         4
49 #define BSSRDF_MAX_BOUNCES                      256
50 #define LOCAL_MAX_HITS                          4
51
52 #define BECKMANN_TABLE_SIZE             256
53
54 #define SHADER_NONE                             (~0)
55 #define OBJECT_NONE                             (~0)
56 #define PRIM_NONE                               (~0)
57 #define LAMP_NONE                               (~0)
58
59 #define VOLUME_STACK_SIZE               16
60
61 /* Split kernel constants */
62 #define WORK_POOL_SIZE_GPU 64
63 #define WORK_POOL_SIZE_CPU 1
64 #ifdef __KERNEL_GPU__
65 #  define WORK_POOL_SIZE WORK_POOL_SIZE_GPU
66 #else
67 #  define WORK_POOL_SIZE WORK_POOL_SIZE_CPU
68 #endif
69
70
71 #define SHADER_SORT_BLOCK_SIZE 2048
72
73 #ifdef __KERNEL_OPENCL__
74 #  define SHADER_SORT_LOCAL_SIZE 64
75 #elif defined(__KERNEL_CUDA__)
76 #  define SHADER_SORT_LOCAL_SIZE 32
77 #else
78 #  define SHADER_SORT_LOCAL_SIZE 1
79 #endif
80
81
82 /* Device capabilities */
83 #ifdef __KERNEL_CPU__
84 #  ifdef __KERNEL_SSE2__
85 #    define __QBVH__
86 #  endif
87 #  define __KERNEL_SHADING__
88 #  define __KERNEL_ADV_SHADING__
89 #  define __BRANCHED_PATH__
90 #  ifdef WITH_OSL
91 #    define __OSL__
92 #  endif
93 #  define __PRINCIPLED__
94 #  define __SUBSURFACE__
95 #  define __CMJ__
96 #  define __VOLUME__
97 #  define __VOLUME_SCATTER__
98 #  define __SHADOW_RECORD_ALL__
99 #  define __VOLUME_DECOUPLED__
100 #  define __VOLUME_RECORD_ALL__
101 #endif  /* __KERNEL_CPU__ */
102
103 #ifdef __KERNEL_CUDA__
104 #  define __KERNEL_SHADING__
105 #  define __KERNEL_ADV_SHADING__
106 #  define __VOLUME__
107 #  define __VOLUME_SCATTER__
108 #  define __SUBSURFACE__
109 #  define __PRINCIPLED__
110 #  define __SHADOW_RECORD_ALL__
111 #  define __CMJ__
112 #  ifndef __SPLIT_KERNEL__
113 #    define __BRANCHED_PATH__
114 #  endif
115 #endif  /* __KERNEL_CUDA__ */
116
117 #ifdef __KERNEL_OPENCL__
118
119 /* keep __KERNEL_ADV_SHADING__ in sync with opencl_kernel_use_advanced_shading! */
120
121 #  ifdef __KERNEL_OPENCL_NVIDIA__
122 #    define __KERNEL_SHADING__
123 #    define __KERNEL_ADV_SHADING__
124 #    define __SUBSURFACE__
125 #    define __PRINCIPLED__
126 #    define __VOLUME__
127 #    define __VOLUME_SCATTER__
128 #    define __SHADOW_RECORD_ALL__
129 #    define __CMJ__
130 #    define __BRANCHED_PATH__
131 #  endif  /* __KERNEL_OPENCL_NVIDIA__ */
132
133 #  ifdef __KERNEL_OPENCL_APPLE__
134 #    define __KERNEL_SHADING__
135 #    define __KERNEL_ADV_SHADING__
136 #    define __PRINCIPLED__
137 #    define __CMJ__
138 /* TODO(sergey): Currently experimental section is ignored here,
139  * this is because megakernel in device_opencl does not support
140  * custom cflags depending on the scene features.
141  */
142 #  endif  /* __KERNEL_OPENCL_APPLE__ */
143
144 #  ifdef __KERNEL_OPENCL_AMD__
145 #    define __CL_USE_NATIVE__
146 #    define __KERNEL_SHADING__
147 #    define __KERNEL_ADV_SHADING__
148 #    define __SUBSURFACE__
149 #    define __PRINCIPLED__
150 #    define __VOLUME__
151 #    define __VOLUME_SCATTER__
152 #    define __SHADOW_RECORD_ALL__
153 #    define __CMJ__
154 #    define __BRANCHED_PATH__
155 #  endif  /* __KERNEL_OPENCL_AMD__ */
156
157 #  ifdef __KERNEL_OPENCL_INTEL_CPU__
158 #    define __CL_USE_NATIVE__
159 #    define __KERNEL_SHADING__
160 #    define __KERNEL_ADV_SHADING__
161 #    define __PRINCIPLED__
162 #    define __CMJ__
163 #  endif  /* __KERNEL_OPENCL_INTEL_CPU__ */
164
165 #endif  /* __KERNEL_OPENCL__ */
166
167 /* Kernel features */
168 #define __SOBOL__
169 #define __INSTANCING__
170 #define __DPDU__
171 #define __UV__
172 #define __BACKGROUND__
173 #define __CAUSTICS_TRICKS__
174 #define __VISIBILITY_FLAG__
175 #define __RAY_DIFFERENTIALS__
176 #define __CAMERA_CLIPPING__
177 #define __INTERSECTION_REFINE__
178 #define __CLAMP_SAMPLE__
179 #define __PATCH_EVAL__
180 #define __SHADOW_TRICKS__
181 #define __DENOISING_FEATURES__
182 #define __SHADER_RAYTRACE__
183
184 #ifdef __KERNEL_SHADING__
185 #  define __SVM__
186 #  define __EMISSION__
187 #  define __TEXTURES__
188 #  define __EXTRA_NODES__
189 #  define __HOLDOUT__
190 #endif
191
192 #ifdef __KERNEL_ADV_SHADING__
193 #  define __MULTI_CLOSURE__
194 #  define __TRANSPARENT_SHADOWS__
195 #  define __PASSES__
196 #  define __BACKGROUND_MIS__
197 #  define __LAMP_MIS__
198 #  define __AO__
199 #  define __CAMERA_MOTION__
200 #  define __OBJECT_MOTION__
201 #  define __HAIR__
202 #  define __BAKING__
203 #endif
204
205 /* Scene-based selective features compilation. */
206 #ifdef __NO_CAMERA_MOTION__
207 #  undef __CAMERA_MOTION__
208 #endif
209 #ifdef __NO_OBJECT_MOTION__
210 #  undef __OBJECT_MOTION__
211 #endif
212 #ifdef __NO_HAIR__
213 #  undef __HAIR__
214 #endif
215 #ifdef __NO_VOLUME__
216 #  undef __VOLUME__
217 #  undef __VOLUME_SCATTER__
218 #endif
219 #ifdef __NO_SUBSURFACE__
220 #  undef __SUBSURFACE__
221 #endif
222 #ifdef __NO_BAKING__
223 #  undef __BAKING__
224 #endif
225 #ifdef __NO_BRANCHED_PATH__
226 #  undef __BRANCHED_PATH__
227 #endif
228 #ifdef __NO_PATCH_EVAL__
229 #  undef __PATCH_EVAL__
230 #endif
231 #ifdef __NO_TRANSPARENT__
232 #  undef __TRANSPARENT_SHADOWS__
233 #endif
234 #ifdef __NO_SHADOW_TRICKS__
235 #  undef __SHADOW_TRICKS__
236 #endif
237 #ifdef __NO_PRINCIPLED__
238 #  undef __PRINCIPLED__
239 #endif
240 #ifdef __NO_DENOISING__
241 #  undef __DENOISING_FEATURES__
242 #endif
243 #ifdef __NO_SHADER_RAYTRACE__
244 #  undef __SHADER_RAYTRACE__
245 #endif
246
247 /* Features that enable others */
248 #ifdef WITH_CYCLES_DEBUG
249 #  define __KERNEL_DEBUG__
250 #endif
251
252 #if defined(__SUBSURFACE__) || defined(__SHADER_RAYTRACE__)
253 #  define __BVH_LOCAL__
254 #endif
255
256 /* Shader Evaluation */
257
258 typedef enum ShaderEvalType {
259         SHADER_EVAL_DISPLACE,
260         SHADER_EVAL_BACKGROUND,
261         /* bake types */
262         SHADER_EVAL_BAKE, /* no real shade, it's used in the code to
263                            * differentiate the type of shader eval from the above
264                            */
265         /* data passes */
266         SHADER_EVAL_NORMAL,
267         SHADER_EVAL_UV,
268         SHADER_EVAL_DIFFUSE_COLOR,
269         SHADER_EVAL_GLOSSY_COLOR,
270         SHADER_EVAL_TRANSMISSION_COLOR,
271         SHADER_EVAL_SUBSURFACE_COLOR,
272         SHADER_EVAL_EMISSION,
273
274         /* light passes */
275         SHADER_EVAL_AO,
276         SHADER_EVAL_COMBINED,
277         SHADER_EVAL_SHADOW,
278         SHADER_EVAL_DIFFUSE,
279         SHADER_EVAL_GLOSSY,
280         SHADER_EVAL_TRANSMISSION,
281         SHADER_EVAL_SUBSURFACE,
282
283         /* extra */
284         SHADER_EVAL_ENVIRONMENT,
285 } ShaderEvalType;
286
287 /* Path Tracing
288  * note we need to keep the u/v pairs at even values */
289
290 enum PathTraceDimension {
291         PRNG_FILTER_U = 0,
292         PRNG_FILTER_V = 1,
293         PRNG_LENS_U = 2,
294         PRNG_LENS_V = 3,
295         PRNG_TIME = 4,
296         PRNG_UNUSED_0 = 5,
297         PRNG_UNUSED_1 = 6,      /* for some reason (6, 7) is a bad sobol pattern */
298         PRNG_UNUSED_2 = 7,  /* with a low number of samples (< 64) */
299         PRNG_BASE_NUM = 10,
300
301         PRNG_BSDF_U = 0,
302         PRNG_BSDF_V = 1,
303         PRNG_LIGHT_U = 2,
304         PRNG_LIGHT_V = 3,
305         PRNG_LIGHT_TERMINATE = 4,
306         PRNG_TERMINATE = 5,
307         PRNG_PHASE_CHANNEL = 6,
308         PRNG_SCATTER_DISTANCE = 7,
309         PRNG_BOUNCE_NUM = 8,
310
311         PRNG_BEVEL_U = 6, /* reuse volume dimension, correlation won't harm */
312         PRNG_BEVEL_V = 7,
313 };
314
315 enum SamplingPattern {
316         SAMPLING_PATTERN_SOBOL = 0,
317         SAMPLING_PATTERN_CMJ = 1,
318
319         SAMPLING_NUM_PATTERNS,
320 };
321
322 /* these flags values correspond to raytypes in osl.cpp, so keep them in sync! */
323
324 enum PathRayFlag {
325         PATH_RAY_CAMERA              = (1 << 0),
326         PATH_RAY_REFLECT             = (1 << 1),
327         PATH_RAY_TRANSMIT            = (1 << 2),
328         PATH_RAY_DIFFUSE             = (1 << 3),
329         PATH_RAY_GLOSSY              = (1 << 4),
330         PATH_RAY_SINGULAR            = (1 << 5),
331         PATH_RAY_TRANSPARENT         = (1 << 6),
332
333         PATH_RAY_SHADOW_OPAQUE_NON_CATCHER       = (1 << 7),
334         PATH_RAY_SHADOW_OPAQUE_CATCHER           = (1 << 8),
335         PATH_RAY_SHADOW_OPAQUE                   = (PATH_RAY_SHADOW_OPAQUE_NON_CATCHER|PATH_RAY_SHADOW_OPAQUE_CATCHER),
336         PATH_RAY_SHADOW_TRANSPARENT_NON_CATCHER  = (1 << 9),
337         PATH_RAY_SHADOW_TRANSPARENT_CATCHER      = (1 << 10),
338         PATH_RAY_SHADOW_TRANSPARENT              = (PATH_RAY_SHADOW_TRANSPARENT_NON_CATCHER|PATH_RAY_SHADOW_TRANSPARENT_CATCHER),
339         PATH_RAY_SHADOW_NON_CATCHER              = (PATH_RAY_SHADOW_OPAQUE_NON_CATCHER|PATH_RAY_SHADOW_TRANSPARENT_NON_CATCHER),
340         PATH_RAY_SHADOW                          = (PATH_RAY_SHADOW_OPAQUE|PATH_RAY_SHADOW_TRANSPARENT),
341
342         PATH_RAY_CURVE               = (1 << 11), /* visibility flag to define curve segments */
343         PATH_RAY_VOLUME_SCATTER      = (1 << 12), /* volume scattering */
344
345         /* Special flag to tag unaligned BVH nodes. */
346         PATH_RAY_NODE_UNALIGNED = (1 << 13),
347
348         PATH_RAY_ALL_VISIBILITY = ((1 << 14)-1),
349
350         /* Don't apply multiple importance sampling weights to emission from
351          * lamp or surface hits, because they were not direct light sampled. */
352         PATH_RAY_MIS_SKIP                    = (1 << 14),
353         /* Diffuse bounce earlier in the path, skip SSS to improve performance
354          * and avoid branching twice with disk sampling SSS. */
355         PATH_RAY_DIFFUSE_ANCESTOR            = (1 << 15),
356         /* Single pass has been written. */
357         PATH_RAY_SINGLE_PASS_DONE            = (1 << 16),
358         /* Ray is behind a shadow catcher .*/
359         PATH_RAY_SHADOW_CATCHER              = (1 << 17),
360         /* Store shadow data for shadow catcher or denoising. */
361         PATH_RAY_STORE_SHADOW_INFO           = (1 << 18),
362         /* Zero background alpha, for camera or transparent glass rays. */
363         PATH_RAY_TRANSPARENT_BACKGROUND      = (1 << 19),
364         /* Terminate ray immediately at next bounce. */
365         PATH_RAY_TERMINATE_IMMEDIATE         = (1 << 20),
366         /* Ray is to be terminated, but continue with transparent bounces and
367          * emission as long as we encounter them. This is required to make the
368          * MIS between direct and indirect light rays match, as shadow rays go
369          * through transparent surfaces to reach emisison too. */
370         PATH_RAY_TERMINATE_AFTER_TRANSPARENT = (1 << 21),
371         /* Ray is to be terminated. */
372         PATH_RAY_TERMINATE                   = (PATH_RAY_TERMINATE_IMMEDIATE|PATH_RAY_TERMINATE_AFTER_TRANSPARENT),
373         /* Path and shader is being evaluated for direct lighting emission. */
374         PATH_RAY_EMISSION                    = (1 << 22)
375 };
376
377 /* Closure Label */
378
379 typedef enum ClosureLabel {
380         LABEL_NONE = 0,
381         LABEL_TRANSMIT = 1,
382         LABEL_REFLECT = 2,
383         LABEL_DIFFUSE = 4,
384         LABEL_GLOSSY = 8,
385         LABEL_SINGULAR = 16,
386         LABEL_TRANSPARENT = 32,
387         LABEL_VOLUME_SCATTER = 64,
388         LABEL_TRANSMIT_TRANSPARENT = 128,
389 } ClosureLabel;
390
391 /* Render Passes */
392
393 #define PASS_NAME_JOIN(a, b) a ## _ ## b
394 #define PASSMASK(pass) (1 << ((PASS_NAME_JOIN(PASS, pass)) % 32))
395
396 #define PASSMASK_COMPONENT(comp) (PASSMASK(PASS_NAME_JOIN(comp, DIRECT)) |   \
397                                   PASSMASK(PASS_NAME_JOIN(comp, INDIRECT)) | \
398                                   PASSMASK(PASS_NAME_JOIN(comp, COLOR)))
399
400 typedef enum PassType {
401         PASS_NONE = 0,
402
403         /* Main passes */
404         PASS_COMBINED = 1,
405         PASS_DEPTH,
406         PASS_NORMAL,
407         PASS_UV,
408         PASS_OBJECT_ID,
409         PASS_MATERIAL_ID,
410         PASS_MOTION,
411         PASS_MOTION_WEIGHT,
412 #ifdef __KERNEL_DEBUG__
413         PASS_BVH_TRAVERSED_NODES,
414         PASS_BVH_TRAVERSED_INSTANCES,
415         PASS_BVH_INTERSECTIONS,
416         PASS_RAY_BOUNCES,
417 #endif
418         PASS_RENDER_TIME,
419         PASS_CATEGORY_MAIN_END = 31,
420
421         PASS_MIST = 32,
422         PASS_EMISSION,
423         PASS_BACKGROUND,
424         PASS_AO,
425         PASS_SHADOW,
426         PASS_LIGHT, /* no real pass, used to force use_light_pass */
427         PASS_DIFFUSE_DIRECT,
428         PASS_DIFFUSE_INDIRECT,
429         PASS_DIFFUSE_COLOR,
430         PASS_GLOSSY_DIRECT,
431         PASS_GLOSSY_INDIRECT,
432         PASS_GLOSSY_COLOR,
433         PASS_TRANSMISSION_DIRECT,
434         PASS_TRANSMISSION_INDIRECT,
435         PASS_TRANSMISSION_COLOR,
436         PASS_SUBSURFACE_DIRECT,
437         PASS_SUBSURFACE_INDIRECT,
438         PASS_SUBSURFACE_COLOR,
439         PASS_VOLUME_DIRECT,
440         PASS_VOLUME_INDIRECT,
441         /* No Scatter color since it's tricky to define what it would even mean. */
442         PASS_CATEGORY_LIGHT_END = 63,
443 } PassType;
444
445 #define PASS_ANY (~0)
446
447 typedef enum DenoisingPassOffsets {
448         DENOISING_PASS_NORMAL             = 0,
449         DENOISING_PASS_NORMAL_VAR         = 3,
450         DENOISING_PASS_ALBEDO             = 6,
451         DENOISING_PASS_ALBEDO_VAR         = 9,
452         DENOISING_PASS_DEPTH              = 12,
453         DENOISING_PASS_DEPTH_VAR          = 13,
454         DENOISING_PASS_SHADOW_A           = 14,
455         DENOISING_PASS_SHADOW_B           = 17,
456         DENOISING_PASS_COLOR              = 20,
457         DENOISING_PASS_COLOR_VAR          = 23,
458
459         DENOISING_PASS_SIZE_BASE          = 26,
460         DENOISING_PASS_SIZE_CLEAN         = 3,
461 } DenoisingPassOffsets;
462
463 typedef enum eBakePassFilter {
464         BAKE_FILTER_NONE = 0,
465         BAKE_FILTER_DIRECT = (1 << 0),
466         BAKE_FILTER_INDIRECT = (1 << 1),
467         BAKE_FILTER_COLOR = (1 << 2),
468         BAKE_FILTER_DIFFUSE = (1 << 3),
469         BAKE_FILTER_GLOSSY = (1 << 4),
470         BAKE_FILTER_TRANSMISSION = (1 << 5),
471         BAKE_FILTER_SUBSURFACE = (1 << 6),
472         BAKE_FILTER_EMISSION = (1 << 7),
473         BAKE_FILTER_AO = (1 << 8),
474 } eBakePassFilter;
475
476 typedef enum BakePassFilterCombos {
477         BAKE_FILTER_COMBINED = (
478             BAKE_FILTER_DIRECT |
479             BAKE_FILTER_INDIRECT |
480             BAKE_FILTER_DIFFUSE |
481             BAKE_FILTER_GLOSSY |
482             BAKE_FILTER_TRANSMISSION |
483             BAKE_FILTER_SUBSURFACE |
484             BAKE_FILTER_EMISSION |
485             BAKE_FILTER_AO),
486         BAKE_FILTER_DIFFUSE_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_DIFFUSE),
487         BAKE_FILTER_GLOSSY_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_GLOSSY),
488         BAKE_FILTER_TRANSMISSION_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_TRANSMISSION),
489         BAKE_FILTER_SUBSURFACE_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_SUBSURFACE),
490         BAKE_FILTER_DIFFUSE_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_DIFFUSE),
491         BAKE_FILTER_GLOSSY_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_GLOSSY),
492         BAKE_FILTER_TRANSMISSION_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_TRANSMISSION),
493         BAKE_FILTER_SUBSURFACE_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_SUBSURFACE),
494 } BakePassFilterCombos;
495
496 typedef enum DenoiseFlag {
497         DENOISING_CLEAN_DIFFUSE_DIR      = (1 << 0),
498         DENOISING_CLEAN_DIFFUSE_IND      = (1 << 1),
499         DENOISING_CLEAN_GLOSSY_DIR       = (1 << 2),
500         DENOISING_CLEAN_GLOSSY_IND       = (1 << 3),
501         DENOISING_CLEAN_TRANSMISSION_DIR = (1 << 4),
502         DENOISING_CLEAN_TRANSMISSION_IND = (1 << 5),
503         DENOISING_CLEAN_SUBSURFACE_DIR   = (1 << 6),
504         DENOISING_CLEAN_SUBSURFACE_IND   = (1 << 7),
505         DENOISING_CLEAN_ALL_PASSES       = (1 << 8)-1,
506 } DenoiseFlag;
507
508 #ifdef __KERNEL_DEBUG__
509 /* NOTE: This is a runtime-only struct, alignment is not
510  * really important here.
511  */
512 typedef struct DebugData {
513         int num_bvh_traversed_nodes;
514         int num_bvh_traversed_instances;
515         int num_bvh_intersections;
516         int num_ray_bounces;
517 } DebugData;
518 #endif
519
520 typedef ccl_addr_space struct PathRadianceState {
521 #ifdef __PASSES__
522         float3 diffuse;
523         float3 glossy;
524         float3 transmission;
525         float3 subsurface;
526         float3 scatter;
527
528         float3 direct;
529 #endif
530 } PathRadianceState;
531
532 typedef ccl_addr_space struct PathRadiance {
533 #ifdef __PASSES__
534         int use_light_pass;
535 #endif
536
537         float transparent;
538         float3 emission;
539 #ifdef __PASSES__
540         float3 background;
541         float3 ao;
542
543         float3 indirect;
544         float3 direct_emission;
545
546         float3 color_diffuse;
547         float3 color_glossy;
548         float3 color_transmission;
549         float3 color_subsurface;
550
551         float3 direct_diffuse;
552         float3 direct_glossy;
553         float3 direct_transmission;
554         float3 direct_subsurface;
555         float3 direct_scatter;
556
557         float3 indirect_diffuse;
558         float3 indirect_glossy;
559         float3 indirect_transmission;
560         float3 indirect_subsurface;
561         float3 indirect_scatter;
562
563         float4 shadow;
564         float mist;
565 #endif
566
567         struct PathRadianceState state;
568
569 #ifdef __SHADOW_TRICKS__
570         /* Total light reachable across the path, ignoring shadow blocked queries. */
571         float3 path_total;
572         /* Total light reachable across the path with shadow blocked queries
573          * applied here.
574          *
575          * Dividing this figure by path_total will give estimate of shadow pass.
576          */
577         float3 path_total_shaded;
578
579         /* Color of the background on which shadow is alpha-overed. */
580         float3 shadow_background_color;
581
582         /* Path radiance sum and throughput at the moment when ray hits shadow
583          * catcher object.
584          */
585         float shadow_throughput;
586
587         /* Accumulated transparency along the path after shadow catcher bounce. */
588         float shadow_transparency;
589
590         /* Indicate if any shadow catcher data is set. */
591         int has_shadow_catcher;
592 #endif
593
594 #ifdef __DENOISING_FEATURES__
595         float3 denoising_normal;
596         float3 denoising_albedo;
597         float denoising_depth;
598 #endif  /* __DENOISING_FEATURES__ */
599
600 #ifdef __KERNEL_DEBUG__
601         DebugData debug_data;
602 #endif /* __KERNEL_DEBUG__ */
603 } PathRadiance;
604
605 typedef struct BsdfEval {
606 #ifdef __PASSES__
607         int use_light_pass;
608 #endif
609
610         float3 diffuse;
611 #ifdef __PASSES__
612         float3 glossy;
613         float3 transmission;
614         float3 transparent;
615         float3 subsurface;
616         float3 scatter;
617 #endif
618 #ifdef __SHADOW_TRICKS__
619         float3 sum_no_mis;
620 #endif
621 } BsdfEval;
622
623 /* Shader Flag */
624
625 typedef enum ShaderFlag {
626         SHADER_SMOOTH_NORMAL = (1 << 31),
627         SHADER_CAST_SHADOW = (1 << 30),
628         SHADER_AREA_LIGHT = (1 << 29),
629         SHADER_USE_MIS = (1 << 28),
630         SHADER_EXCLUDE_DIFFUSE = (1 << 27),
631         SHADER_EXCLUDE_GLOSSY = (1 << 26),
632         SHADER_EXCLUDE_TRANSMIT = (1 << 25),
633         SHADER_EXCLUDE_CAMERA = (1 << 24),
634         SHADER_EXCLUDE_SCATTER = (1 << 23),
635         SHADER_EXCLUDE_ANY = (SHADER_EXCLUDE_DIFFUSE|SHADER_EXCLUDE_GLOSSY|SHADER_EXCLUDE_TRANSMIT|SHADER_EXCLUDE_CAMERA|SHADER_EXCLUDE_SCATTER),
636
637         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT|SHADER_USE_MIS|SHADER_EXCLUDE_ANY)
638 } ShaderFlag;
639
640 /* Light Type */
641
642 typedef enum LightType {
643         LIGHT_POINT,
644         LIGHT_DISTANT,
645         LIGHT_BACKGROUND,
646         LIGHT_AREA,
647         LIGHT_SPOT,
648         LIGHT_TRIANGLE
649 } LightType;
650
651 /* Camera Type */
652
653 enum CameraType {
654         CAMERA_PERSPECTIVE,
655         CAMERA_ORTHOGRAPHIC,
656         CAMERA_PANORAMA
657 };
658
659 /* Panorama Type */
660
661 enum PanoramaType {
662         PANORAMA_EQUIRECTANGULAR = 0,
663         PANORAMA_FISHEYE_EQUIDISTANT = 1,
664         PANORAMA_FISHEYE_EQUISOLID = 2,
665         PANORAMA_MIRRORBALL = 3,
666
667         PANORAMA_NUM_TYPES,
668 };
669
670 /* Differential */
671
672 typedef struct differential3 {
673         float3 dx;
674         float3 dy;
675 } differential3;
676
677 typedef struct differential {
678         float dx;
679         float dy;
680 } differential;
681
682 /* Ray */
683
684 typedef struct Ray {
685 /* TODO(sergey): This is only needed because current AMD
686  * compiler has hard time building the kernel with this
687  * reshuffle. And at the same time reshuffle will cause
688  * less optimal CPU code in certain places.
689  *
690  * We'll get rid of this nasty exception once AMD compiler
691  * is fixed.
692  */
693 #ifndef __KERNEL_OPENCL_AMD__
694         float3 P;               /* origin */
695         float3 D;               /* direction */
696
697         float t;                /* length of the ray */
698         float time;             /* time (for motion blur) */
699 #else
700         float t;                /* length of the ray */
701         float time;             /* time (for motion blur) */
702         float3 P;               /* origin */
703         float3 D;               /* direction */
704 #endif
705
706 #ifdef __RAY_DIFFERENTIALS__
707         differential3 dP;
708         differential3 dD;
709 #endif
710 } Ray;
711
712 /* Intersection */
713
714 typedef struct Intersection {
715         float t, u, v;
716         int prim;
717         int object;
718         int type;
719
720 #ifdef __KERNEL_DEBUG__
721         int num_traversed_nodes;
722         int num_traversed_instances;
723         int num_intersections;
724 #endif
725 } Intersection;
726
727 /* Primitives */
728
729 typedef enum PrimitiveType {
730         PRIMITIVE_NONE            = 0,
731         PRIMITIVE_TRIANGLE        = (1 << 0),
732         PRIMITIVE_MOTION_TRIANGLE = (1 << 1),
733         PRIMITIVE_CURVE           = (1 << 2),
734         PRIMITIVE_MOTION_CURVE    = (1 << 3),
735         /* Lamp primitive is not included below on purpose,
736          * since it is no real traceable primitive.
737          */
738         PRIMITIVE_LAMP            = (1 << 4),
739
740         PRIMITIVE_ALL_TRIANGLE = (PRIMITIVE_TRIANGLE|PRIMITIVE_MOTION_TRIANGLE),
741         PRIMITIVE_ALL_CURVE = (PRIMITIVE_CURVE|PRIMITIVE_MOTION_CURVE),
742         PRIMITIVE_ALL_MOTION = (PRIMITIVE_MOTION_TRIANGLE|PRIMITIVE_MOTION_CURVE),
743         PRIMITIVE_ALL = (PRIMITIVE_ALL_TRIANGLE|PRIMITIVE_ALL_CURVE),
744
745         /* Total number of different traceable primitives.
746          * NOTE: This is an actual value, not a bitflag.
747          */
748         PRIMITIVE_NUM_TOTAL = 4,
749 } PrimitiveType;
750
751 #define PRIMITIVE_PACK_SEGMENT(type, segment) ((segment << PRIMITIVE_NUM_TOTAL) | (type))
752 #define PRIMITIVE_UNPACK_SEGMENT(type) (type >> PRIMITIVE_NUM_TOTAL)
753
754 /* Attributes */
755
756 typedef enum AttributePrimitive {
757         ATTR_PRIM_TRIANGLE = 0,
758         ATTR_PRIM_CURVE,
759         ATTR_PRIM_SUBD,
760
761         ATTR_PRIM_TYPES
762 } AttributePrimitive;
763
764 typedef enum AttributeElement {
765         ATTR_ELEMENT_NONE,
766         ATTR_ELEMENT_OBJECT,
767         ATTR_ELEMENT_MESH,
768         ATTR_ELEMENT_FACE,
769         ATTR_ELEMENT_VERTEX,
770         ATTR_ELEMENT_VERTEX_MOTION,
771         ATTR_ELEMENT_CORNER,
772         ATTR_ELEMENT_CORNER_BYTE,
773         ATTR_ELEMENT_CURVE,
774         ATTR_ELEMENT_CURVE_KEY,
775         ATTR_ELEMENT_CURVE_KEY_MOTION,
776         ATTR_ELEMENT_VOXEL
777 } AttributeElement;
778
779 typedef enum AttributeStandard {
780         ATTR_STD_NONE = 0,
781         ATTR_STD_VERTEX_NORMAL,
782         ATTR_STD_FACE_NORMAL,
783         ATTR_STD_UV,
784         ATTR_STD_UV_TANGENT,
785         ATTR_STD_UV_TANGENT_SIGN,
786         ATTR_STD_GENERATED,
787         ATTR_STD_GENERATED_TRANSFORM,
788         ATTR_STD_POSITION_UNDEFORMED,
789         ATTR_STD_POSITION_UNDISPLACED,
790         ATTR_STD_MOTION_VERTEX_POSITION,
791         ATTR_STD_MOTION_VERTEX_NORMAL,
792         ATTR_STD_PARTICLE,
793         ATTR_STD_CURVE_INTERCEPT,
794         ATTR_STD_CURVE_RANDOM,
795         ATTR_STD_PTEX_FACE_ID,
796         ATTR_STD_PTEX_UV,
797         ATTR_STD_VOLUME_DENSITY,
798         ATTR_STD_VOLUME_COLOR,
799         ATTR_STD_VOLUME_FLAME,
800         ATTR_STD_VOLUME_HEAT,
801         ATTR_STD_VOLUME_VELOCITY,
802         ATTR_STD_POINTINESS,
803         ATTR_STD_NUM,
804
805         ATTR_STD_NOT_FOUND = ~0
806 } AttributeStandard;
807
808 typedef enum AttributeFlag {
809         ATTR_FINAL_SIZE = (1 << 0),
810         ATTR_SUBDIVIDED = (1 << 1),
811 } AttributeFlag;
812
813 typedef struct AttributeDescriptor {
814         AttributeElement element;
815         NodeAttributeType type;
816         uint flags; /* see enum AttributeFlag */
817         int offset;
818 } AttributeDescriptor;
819
820 /* Closure data */
821
822 #ifdef __MULTI_CLOSURE__
823 #  ifdef __SPLIT_KERNEL__
824 #    define MAX_CLOSURE 1
825 #  else
826 #    ifndef __MAX_CLOSURE__
827 #       define MAX_CLOSURE 64
828 #    else
829 #      define MAX_CLOSURE __MAX_CLOSURE__
830 #    endif
831 #  endif
832 #else
833 #  define MAX_CLOSURE 1
834 #endif
835
836 /* This struct is the base class for all closures. The common members are
837  * duplicated in all derived classes since we don't have C++ in the kernel
838  * yet, and because it lets us lay out the members to minimize padding. The
839  * weight member is located at the beginning of the struct for this reason.
840  *
841  * ShaderClosure has a fixed size, and any extra space must be allocated
842  * with closure_alloc_extra().
843  *
844  * We pad the struct to 80 bytes and ensure it is aligned to 16 bytes, which
845  * we assume to be the maximum required alignment for any struct. */
846
847 #define SHADER_CLOSURE_BASE \
848         float3 weight; \
849         ClosureType type; \
850         float sample_weight; \
851         float3 N
852
853 typedef ccl_addr_space struct ccl_align(16) ShaderClosure {
854         SHADER_CLOSURE_BASE;
855
856         float data[10]; /* pad to 80 bytes */
857 } ShaderClosure;
858
859 /* Shader Data
860  *
861  * Main shader state at a point on the surface or in a volume. All coordinates
862  * are in world space.
863  */
864
865 enum ShaderDataFlag {
866         /* Runtime flags. */
867
868         /* Set when ray hits backside of surface. */
869         SD_BACKFACING      = (1 << 0),
870         /* Shader has non-zero emission. */
871         SD_EMISSION        = (1 << 1),
872         /* Shader has BSDF closure. */
873         SD_BSDF            = (1 << 2),
874         /* Shader has non-singular BSDF closure. */
875         SD_BSDF_HAS_EVAL   = (1 << 3),
876         /* Shader has BSSRDF closure. */
877         SD_BSSRDF          = (1 << 4),
878         /* Shader has holdout closure. */
879         SD_HOLDOUT         = (1 << 5),
880         /* Shader has non-zero volume extinction. */
881         SD_EXTINCTION      = (1 << 6),
882         /* Shader has have volume phase (scatter) closure. */
883         SD_SCATTER         = (1 << 7),
884         /* Shader has AO closure. */
885         SD_AO              = (1 << 8),
886         /* Shader has transparent closure. */
887         SD_TRANSPARENT     = (1 << 9),
888         /* BSDF requires LCG for evaluation. */
889         SD_BSDF_NEEDS_LCG  = (1 << 10),
890
891         SD_CLOSURE_FLAGS = (SD_EMISSION |
892                             SD_BSDF |
893                             SD_BSDF_HAS_EVAL |
894                             SD_BSSRDF |
895                             SD_HOLDOUT |
896                             SD_EXTINCTION |
897                             SD_SCATTER |
898                             SD_AO |
899                             SD_BSDF_NEEDS_LCG),
900
901         /* Shader flags. */
902
903         /* direct light sample */
904         SD_USE_MIS                = (1 << 16),
905         /* Has transparent shadow. */
906         SD_HAS_TRANSPARENT_SHADOW = (1 << 17),
907         /* Has volume shader. */
908         SD_HAS_VOLUME             = (1 << 18),
909         /* Has only volume shader, no surface. */
910         SD_HAS_ONLY_VOLUME        = (1 << 19),
911         /* Has heterogeneous volume. */
912         SD_HETEROGENEOUS_VOLUME   = (1 << 20),
913         /* BSSRDF normal uses bump. */
914         SD_HAS_BSSRDF_BUMP        = (1 << 21),
915         /* Use equiangular volume sampling */
916         SD_VOLUME_EQUIANGULAR     = (1 << 22),
917         /* Use multiple importance volume sampling. */
918         SD_VOLUME_MIS             = (1 << 23),
919         /* Use cubic interpolation for voxels. */
920         SD_VOLUME_CUBIC           = (1 << 24),
921         /* Has data connected to the displacement input or uses bump map. */
922         SD_HAS_BUMP               = (1 << 25),
923         /* Has true displacement. */
924         SD_HAS_DISPLACEMENT       = (1 << 26),
925         /* Has constant emission (value stored in __shader_flag) */
926         SD_HAS_CONSTANT_EMISSION  = (1 << 27),
927
928         SD_SHADER_FLAGS = (SD_USE_MIS |
929                            SD_HAS_TRANSPARENT_SHADOW |
930                            SD_HAS_VOLUME |
931                            SD_HAS_ONLY_VOLUME |
932                            SD_HETEROGENEOUS_VOLUME|
933                            SD_HAS_BSSRDF_BUMP |
934                            SD_VOLUME_EQUIANGULAR |
935                            SD_VOLUME_MIS |
936                            SD_VOLUME_CUBIC |
937                            SD_HAS_BUMP |
938                            SD_HAS_DISPLACEMENT |
939                            SD_HAS_CONSTANT_EMISSION)
940 };
941
942         /* Object flags. */
943 enum ShaderDataObjectFlag {
944         /* Holdout for camera rays. */
945         SD_OBJECT_HOLDOUT_MASK           = (1 << 0),
946         /* Has object motion blur. */
947         SD_OBJECT_MOTION                 = (1 << 1),
948         /* Vertices have transform applied. */
949         SD_OBJECT_TRANSFORM_APPLIED      = (1 << 2),
950         /* Vertices have negative scale applied. */
951         SD_OBJECT_NEGATIVE_SCALE_APPLIED = (1 << 3),
952         /* Object has a volume shader. */
953         SD_OBJECT_HAS_VOLUME             = (1 << 4),
954         /* Object intersects AABB of an object with volume shader. */
955         SD_OBJECT_INTERSECTS_VOLUME      = (1 << 5),
956         /* Has position for motion vertices. */
957         SD_OBJECT_HAS_VERTEX_MOTION      = (1 << 6),
958         /* object is used to catch shadows */
959         SD_OBJECT_SHADOW_CATCHER         = (1 << 7),
960
961         SD_OBJECT_FLAGS = (SD_OBJECT_HOLDOUT_MASK |
962                            SD_OBJECT_MOTION |
963                            SD_OBJECT_TRANSFORM_APPLIED |
964                            SD_OBJECT_NEGATIVE_SCALE_APPLIED |
965                            SD_OBJECT_HAS_VOLUME |
966                            SD_OBJECT_INTERSECTS_VOLUME |
967                            SD_OBJECT_SHADOW_CATCHER)
968 };
969
970 typedef ccl_addr_space struct ShaderData {
971         /* position */
972         float3 P;
973         /* smooth normal for shading */
974         float3 N;
975         /* true geometric normal */
976         float3 Ng;
977         /* view/incoming direction */
978         float3 I;
979         /* shader id */
980         int shader;
981         /* booleans describing shader, see ShaderDataFlag */
982         int flag;
983         /* booleans describing object of the shader, see ShaderDataObjectFlag */
984         int object_flag;
985
986         /* primitive id if there is one, ~0 otherwise */
987         int prim;
988
989         /* combined type and curve segment for hair */
990         int type;
991
992         /* parametric coordinates
993          * - barycentric weights for triangles */
994         float u;
995         float v;
996         /* object id if there is one, ~0 otherwise */
997         int object;
998         /* lamp id if there is one, ~0 otherwise */
999         int lamp;
1000
1001         /* motion blur sample time */
1002         float time;
1003
1004         /* length of the ray being shaded */
1005         float ray_length;
1006
1007 #ifdef __RAY_DIFFERENTIALS__
1008         /* differential of P. these are orthogonal to Ng, not N */
1009         differential3 dP;
1010         /* differential of I */
1011         differential3 dI;
1012         /* differential of u, v */
1013         differential du;
1014         differential dv;
1015 #endif
1016 #ifdef __DPDU__
1017         /* differential of P w.r.t. parametric coordinates. note that dPdu is
1018          * not readily suitable as a tangent for shading on triangles. */
1019         float3 dPdu;
1020         float3 dPdv;
1021 #endif
1022
1023 #ifdef __OBJECT_MOTION__
1024         /* object <-> world space transformations, cached to avoid
1025          * re-interpolating them constantly for shading */
1026         Transform ob_tfm;
1027         Transform ob_itfm;
1028 #endif
1029
1030         /* ray start position, only set for backgrounds */
1031         float3 ray_P;
1032         differential3 ray_dP;
1033
1034 #ifdef __OSL__
1035         struct KernelGlobals *osl_globals;
1036         struct PathState *osl_path_state;
1037 #endif
1038
1039         /* LCG state for closures that require additional random numbers. */
1040         uint lcg_state;
1041
1042         /* Closure data, we store a fixed array of closures */
1043         int num_closure;
1044         int num_closure_left;
1045         float randb_closure;
1046         float3 svm_closure_weight;
1047
1048         /* Closure weights summed directly, so we can evaluate
1049          * emission and shadow transparency with MAX_CLOSURE 0. */
1050         float3 closure_emission_background;
1051         float3 closure_transparent_extinction;
1052
1053         /* At the end so we can adjust size in ShaderDataTinyStorage. */
1054         struct ShaderClosure closure[MAX_CLOSURE];
1055 } ShaderData;
1056
1057 typedef ccl_addr_space struct ShaderDataTinyStorage {
1058         char pad[sizeof(ShaderData) - sizeof(ShaderClosure) * MAX_CLOSURE];
1059 } ShaderDataTinyStorage;
1060 #define AS_SHADER_DATA(shader_data_tiny_storage) ((ShaderData*)shader_data_tiny_storage)
1061
1062 /* Path State */
1063
1064 #ifdef __VOLUME__
1065 typedef struct VolumeStack {
1066         int object;
1067         int shader;
1068 } VolumeStack;
1069 #endif
1070
1071 typedef struct PathState {
1072         /* see enum PathRayFlag */
1073         int flag;
1074
1075         /* random number generator state */
1076         uint rng_hash;          /* per pixel hash */
1077         int rng_offset;         /* dimension offset */
1078         int sample;             /* path sample number */
1079         int num_samples;        /* total number of times this path will be sampled */
1080         float branch_factor;    /* number of branches in indirect paths */
1081
1082         /* bounce counting */
1083         int bounce;
1084         int diffuse_bounce;
1085         int glossy_bounce;
1086         int transmission_bounce;
1087         int transparent_bounce;
1088
1089 #ifdef __DENOISING_FEATURES__
1090         float denoising_feature_weight;
1091 #endif  /* __DENOISING_FEATURES__ */
1092
1093         /* multiple importance sampling */
1094         float min_ray_pdf; /* smallest bounce pdf over entire path up to now */
1095         float ray_pdf;     /* last bounce pdf */
1096 #ifdef __LAMP_MIS__
1097         float ray_t;       /* accumulated distance through transparent surfaces */
1098 #endif
1099
1100         /* volume rendering */
1101 #ifdef __VOLUME__
1102         int volume_bounce;
1103         uint rng_congruential;
1104         VolumeStack volume_stack[VOLUME_STACK_SIZE];
1105 #endif
1106 } PathState;
1107
1108 /* Struct to gather multiple nearby intersections. */
1109 typedef struct LocalIntersection {
1110         Ray ray;
1111         float3 weight[LOCAL_MAX_HITS];
1112
1113         int num_hits;
1114         struct Intersection hits[LOCAL_MAX_HITS];
1115         float3 Ng[LOCAL_MAX_HITS];
1116 } LocalIntersection;
1117
1118 /* Subsurface */
1119
1120 /* Struct to gather SSS indirect rays and delay tracing them. */
1121 typedef struct SubsurfaceIndirectRays {
1122         PathState state[BSSRDF_MAX_HITS];
1123
1124         int num_rays;
1125
1126         struct Ray rays[BSSRDF_MAX_HITS];
1127         float3 throughputs[BSSRDF_MAX_HITS];
1128         struct PathRadianceState L_state[BSSRDF_MAX_HITS];
1129 } SubsurfaceIndirectRays;
1130 static_assert(BSSRDF_MAX_HITS <= LOCAL_MAX_HITS, "BSSRDF hits too high.");
1131
1132 /* Constant Kernel Data
1133  *
1134  * These structs are passed from CPU to various devices, and the struct layout
1135  * must match exactly. Structs are padded to ensure 16 byte alignment, and we
1136  * do not use float3 because its size may not be the same on all devices. */
1137
1138 typedef struct KernelCamera {
1139         /* type */
1140         int type;
1141
1142         /* panorama */
1143         int panorama_type;
1144         float fisheye_fov;
1145         float fisheye_lens;
1146         float4 equirectangular_range;
1147
1148         /* stereo */
1149         float interocular_offset;
1150         float convergence_distance;
1151         float pole_merge_angle_from;
1152         float pole_merge_angle_to;
1153
1154         /* matrices */
1155         Transform cameratoworld;
1156         Transform rastertocamera;
1157
1158         /* differentials */
1159         float4 dx;
1160         float4 dy;
1161
1162         /* depth of field */
1163         float aperturesize;
1164         float blades;
1165         float bladesrotation;
1166         float focaldistance;
1167
1168         /* motion blur */
1169         float shuttertime;
1170         int have_motion, have_perspective_motion;
1171
1172         /* clipping */
1173         float nearclip;
1174         float cliplength;
1175
1176         /* sensor size */
1177         float sensorwidth;
1178         float sensorheight;
1179
1180         /* render size */
1181         float width, height;
1182         int resolution;
1183
1184         /* anamorphic lens bokeh */
1185         float inv_aperture_ratio;
1186
1187         int is_inside_volume;
1188
1189         /* more matrices */
1190         Transform screentoworld;
1191         Transform rastertoworld;
1192         /* work around cuda sm 2.0 crash, this seems to
1193          * cross some limit in combination with motion 
1194          * Transform ndctoworld; */
1195         Transform worldtoscreen;
1196         Transform worldtoraster;
1197         Transform worldtondc;
1198         Transform worldtocamera;
1199
1200         MotionTransform motion;
1201
1202         /* Denotes changes in the projective matrix, namely in rastertocamera.
1203          * Used for camera zoom motion blur,
1204          */
1205         PerspectiveMotionTransform perspective_motion;
1206
1207         int shutter_table_offset;
1208
1209         /* Rolling shutter */
1210         int rolling_shutter_type;
1211         float rolling_shutter_duration;
1212
1213         int pad;
1214 } KernelCamera;
1215 static_assert_align(KernelCamera, 16);
1216
1217 typedef struct KernelFilm {
1218         float exposure;
1219         int pass_flag;
1220         int light_pass_flag;
1221         int pass_stride;
1222         int use_light_pass;
1223
1224         int pass_combined;
1225         int pass_depth;
1226         int pass_normal;
1227         int pass_motion;
1228
1229         int pass_motion_weight;
1230         int pass_uv;
1231         int pass_object_id;
1232         int pass_material_id;
1233
1234         int pass_diffuse_color;
1235         int pass_glossy_color;
1236         int pass_transmission_color;
1237         int pass_subsurface_color;
1238         
1239         int pass_diffuse_indirect;
1240         int pass_glossy_indirect;
1241         int pass_transmission_indirect;
1242         int pass_subsurface_indirect;
1243         int pass_volume_indirect;
1244         
1245         int pass_diffuse_direct;
1246         int pass_glossy_direct;
1247         int pass_transmission_direct;
1248         int pass_subsurface_direct;
1249         int pass_volume_direct;
1250         
1251         int pass_emission;
1252         int pass_background;
1253         int pass_ao;
1254         float pass_alpha_threshold;
1255
1256         int pass_shadow;
1257         float pass_shadow_scale;
1258         int filter_table_offset;
1259
1260         int pass_mist;
1261         float mist_start;
1262         float mist_inv_depth;
1263         float mist_falloff;
1264
1265         int pass_denoising_data;
1266         int pass_denoising_clean;
1267         int denoising_flags;
1268
1269         int pad1, pad2, pad3;
1270
1271 #ifdef __KERNEL_DEBUG__
1272         int pass_bvh_traversed_nodes;
1273         int pass_bvh_traversed_instances;
1274         int pass_bvh_intersections;
1275         int pass_ray_bounces;
1276 #endif
1277 } KernelFilm;
1278 static_assert_align(KernelFilm, 16);
1279
1280 typedef struct KernelBackground {
1281         /* only shader index */
1282         int surface_shader;
1283         int volume_shader;
1284         int transparent;
1285         float transparent_roughness_squared_threshold;
1286
1287         /* ambient occlusion */
1288         float ao_factor;
1289         float ao_distance;
1290         float ao_bounces_factor;
1291         float ao_pad;
1292 } KernelBackground;
1293 static_assert_align(KernelBackground, 16);
1294
1295 typedef struct KernelIntegrator {
1296         /* emission */
1297         int use_direct_light;
1298         int use_ambient_occlusion;
1299         int num_distribution;
1300         int num_all_lights;
1301         float pdf_triangles;
1302         float pdf_lights;
1303         int pdf_background_res;
1304         float light_inv_rr_threshold;
1305
1306         /* light portals */
1307         float portal_pdf;
1308         int num_portals;
1309         int portal_offset;
1310
1311         /* bounces */
1312         int max_bounce;
1313
1314         int max_diffuse_bounce;
1315         int max_glossy_bounce;
1316         int max_transmission_bounce;
1317         int max_volume_bounce;
1318
1319         int ao_bounces;
1320
1321         /* transparent */
1322         int transparent_max_bounce;
1323         int transparent_shadows;
1324
1325         /* caustics */
1326         int caustics_reflective;
1327         int caustics_refractive;
1328         float filter_glossy;
1329
1330         /* seed */
1331         int seed;
1332
1333         /* clamp */
1334         float sample_clamp_direct;
1335         float sample_clamp_indirect;
1336
1337         /* branched path */
1338         int branched;
1339         int volume_decoupled;
1340         int diffuse_samples;
1341         int glossy_samples;
1342         int transmission_samples;
1343         int ao_samples;
1344         int mesh_light_samples;
1345         int subsurface_samples;
1346         int sample_all_lights_direct;
1347         int sample_all_lights_indirect;
1348
1349         /* mis */
1350         int use_lamp_mis;
1351
1352         /* sampler */
1353         int sampling_pattern;
1354         int aa_samples;
1355
1356         /* volume render */
1357         int use_volumes;
1358         int volume_max_steps;
1359         float volume_step_size;
1360         int volume_samples;
1361
1362         int start_sample;
1363
1364         int max_closures;
1365 } KernelIntegrator;
1366 static_assert_align(KernelIntegrator, 16);
1367
1368 typedef enum KernelBVHLayout {
1369         BVH_LAYOUT_NONE = 0,
1370
1371         BVH_LAYOUT_BVH2 = (1 << 0),
1372         BVH_LAYOUT_BVH4 = (1 << 1),
1373
1374         BVH_LAYOUT_DEFAULT = BVH_LAYOUT_BVH4,
1375         BVH_LAYOUT_ALL = (unsigned int)(-1),
1376 } KernelBVHLayout;
1377
1378 typedef struct KernelBVH {
1379         /* root node */
1380         int root;
1381         int have_motion;
1382         int have_curves;
1383         int have_instancing;
1384         int bvh_layout;
1385         int use_bvh_steps;
1386         int pad1, pad2;
1387 } KernelBVH;
1388 static_assert_align(KernelBVH, 16);
1389
1390 typedef enum CurveFlag {
1391         /* runtime flags */
1392         CURVE_KN_BACKFACING = 1,                                /* backside of cylinder? */
1393         CURVE_KN_ENCLOSEFILTER = 2,                             /* don't consider strands surrounding start point? */
1394         CURVE_KN_INTERPOLATE = 4,                               /* render as a curve? */
1395         CURVE_KN_ACCURATE = 8,                                  /* use accurate intersections test? */
1396         CURVE_KN_INTERSECTCORRECTION = 16,              /* correct for width after determing closest midpoint? */
1397         CURVE_KN_TRUETANGENTGNORMAL = 32,               /* use tangent normal for geometry? */
1398         CURVE_KN_RIBBONS = 64,                                  /* use flat curve ribbons */
1399 } CurveFlag;
1400
1401 typedef struct KernelCurves {
1402         int curveflags;
1403         int subdivisions;
1404
1405         float minimum_width;
1406         float maximum_width;
1407 } KernelCurves;
1408 static_assert_align(KernelCurves, 16);
1409
1410 typedef struct KernelTables {
1411         int beckmann_offset;
1412         int pad1, pad2, pad3;
1413 } KernelTables;
1414 static_assert_align(KernelTables, 16);
1415
1416 typedef struct KernelData {
1417         KernelCamera cam;
1418         KernelFilm film;
1419         KernelBackground background;
1420         KernelIntegrator integrator;
1421         KernelBVH bvh;
1422         KernelCurves curve;
1423         KernelTables tables;
1424 } KernelData;
1425 static_assert_align(KernelData, 16);
1426
1427 /* Declarations required for split kernel */
1428
1429 /* Macro for queues */
1430 /* Value marking queue's empty slot */
1431 #define QUEUE_EMPTY_SLOT -1
1432
1433 /*
1434  * Queue 1 - Active rays
1435  * Queue 2 - Background queue
1436  * Queue 3 - Shadow ray cast kernel - AO
1437  * Queeu 4 - Shadow ray cast kernel - direct lighting
1438  */
1439
1440 /* Queue names */
1441 enum QueueNumber {
1442         /* All active rays and regenerated rays are enqueued here. */
1443         QUEUE_ACTIVE_AND_REGENERATED_RAYS = 0,
1444
1445         /* All
1446          * 1. Background-hit rays,
1447          * 2. Rays that has exited path-iteration but needs to update output buffer
1448          * 3. Rays to be regenerated
1449          * are enqueued here.
1450          */
1451         QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS,
1452
1453         /* All rays for which a shadow ray should be cast to determine radiance
1454          * contribution for AO are enqueued here.
1455          */
1456         QUEUE_SHADOW_RAY_CAST_AO_RAYS,
1457
1458         /* All rays for which a shadow ray should be cast to determine radiance
1459          * contributing for direct lighting are enqueued here.
1460          */
1461         QUEUE_SHADOW_RAY_CAST_DL_RAYS,
1462
1463         /* Rays sorted according to shader->id */
1464         QUEUE_SHADER_SORTED_RAYS,
1465
1466 #ifdef __BRANCHED_PATH__
1467         /* All rays moving to next iteration of the indirect loop for light */
1468         QUEUE_LIGHT_INDIRECT_ITER,
1469         /* Queue of all inactive rays. These are candidates for sharing work of indirect loops */
1470         QUEUE_INACTIVE_RAYS,
1471 #  ifdef __VOLUME__
1472         /* All rays moving to next iteration of the indirect loop for volumes */
1473         QUEUE_VOLUME_INDIRECT_ITER,
1474 #  endif
1475 #  ifdef __SUBSURFACE__
1476         /* All rays moving to next iteration of the indirect loop for subsurface */
1477         QUEUE_SUBSURFACE_INDIRECT_ITER,
1478 #  endif
1479 #endif  /* __BRANCHED_PATH__ */
1480
1481         NUM_QUEUES
1482 };
1483
1484 /* We use RAY_STATE_MASK to get ray_state */
1485 #define RAY_STATE_MASK 0x0F
1486 #define RAY_FLAG_MASK 0xF0
1487 enum RayState {
1488         RAY_INVALID = 0,
1489         /* Denotes ray is actively involved in path-iteration. */
1490         RAY_ACTIVE,
1491         /* Denotes ray has completed processing all samples and is inactive. */
1492         RAY_INACTIVE,
1493         /* Denoted ray has exited path-iteration and needs to update output buffer. */
1494         RAY_UPDATE_BUFFER,
1495         /* Donotes ray has hit background */
1496         RAY_HIT_BACKGROUND,
1497         /* Denotes ray has to be regenerated */
1498         RAY_TO_REGENERATE,
1499         /* Denotes ray has been regenerated */
1500         RAY_REGENERATED,
1501         /* Denotes ray is moving to next iteration of the branched indirect loop */
1502         RAY_LIGHT_INDIRECT_NEXT_ITER,
1503         RAY_VOLUME_INDIRECT_NEXT_ITER,
1504         RAY_SUBSURFACE_INDIRECT_NEXT_ITER,
1505
1506         /* Ray flags */
1507
1508         /* Flags to denote that the ray is currently evaluating the branched indirect loop */
1509         RAY_BRANCHED_LIGHT_INDIRECT = (1 << 4),
1510         RAY_BRANCHED_VOLUME_INDIRECT = (1 << 5),
1511         RAY_BRANCHED_SUBSURFACE_INDIRECT = (1 << 6),
1512         RAY_BRANCHED_INDIRECT = (RAY_BRANCHED_LIGHT_INDIRECT | RAY_BRANCHED_VOLUME_INDIRECT | RAY_BRANCHED_SUBSURFACE_INDIRECT),
1513
1514         /* Ray is evaluating an iteration of an indirect loop for another thread */
1515         RAY_BRANCHED_INDIRECT_SHARED = (1 << 7),
1516 };
1517
1518 #define ASSIGN_RAY_STATE(ray_state, ray_index, state) (ray_state[ray_index] = ((ray_state[ray_index] & RAY_FLAG_MASK) | state))
1519 #define IS_STATE(ray_state, ray_index, state) ((ray_index) != QUEUE_EMPTY_SLOT && ((ray_state)[(ray_index)] & RAY_STATE_MASK) == (state))
1520 #define ADD_RAY_FLAG(ray_state, ray_index, flag) (ray_state[ray_index] = (ray_state[ray_index] | flag))
1521 #define REMOVE_RAY_FLAG(ray_state, ray_index, flag) (ray_state[ray_index] = (ray_state[ray_index] & (~flag)))
1522 #define IS_FLAG(ray_state, ray_index, flag) (ray_state[ray_index] & flag)
1523
1524 /* Patches */
1525
1526 #define PATCH_MAX_CONTROL_VERTS 16
1527
1528 /* Patch map node flags */
1529
1530 #define PATCH_MAP_NODE_IS_SET (1 << 30)
1531 #define PATCH_MAP_NODE_IS_LEAF (1u << 31)
1532 #define PATCH_MAP_NODE_INDEX_MASK (~(PATCH_MAP_NODE_IS_SET | PATCH_MAP_NODE_IS_LEAF))
1533
1534 /* Work Tiles */
1535
1536 typedef struct WorkTile {
1537         uint x, y, w, h;
1538
1539         uint start_sample;
1540         uint num_samples;
1541
1542         uint offset;
1543         uint stride;
1544
1545         ccl_global float *buffer;
1546 } WorkTile;
1547
1548 CCL_NAMESPACE_END
1549
1550 #endif /*  __KERNEL_TYPES_H__ */
1551