Cycles: random walk subsurface scattering.
[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/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         PATH_RAY_MIS_SKIP               = (1 << 15),
351         PATH_RAY_DIFFUSE_ANCESTOR       = (1 << 16),
352         PATH_RAY_SINGLE_PASS_DONE       = (1 << 17),
353         PATH_RAY_SHADOW_CATCHER         = (1 << 18),
354         PATH_RAY_STORE_SHADOW_INFO      = (1 << 19),
355         PATH_RAY_TRANSPARENT_BACKGROUND = (1 << 20),
356 };
357
358 /* Closure Label */
359
360 typedef enum ClosureLabel {
361         LABEL_NONE = 0,
362         LABEL_TRANSMIT = 1,
363         LABEL_REFLECT = 2,
364         LABEL_DIFFUSE = 4,
365         LABEL_GLOSSY = 8,
366         LABEL_SINGULAR = 16,
367         LABEL_TRANSPARENT = 32,
368         LABEL_VOLUME_SCATTER = 64,
369         LABEL_TRANSMIT_TRANSPARENT = 128,
370 } ClosureLabel;
371
372 /* Render Passes */
373
374 #define PASS_NAME_JOIN(a, b) a ## _ ## b
375 #define PASSMASK(pass) (1 << ((PASS_NAME_JOIN(PASS, pass)) % 32))
376
377 #define PASSMASK_COMPONENT(comp) (PASSMASK(PASS_NAME_JOIN(comp, DIRECT)) |   \
378                                   PASSMASK(PASS_NAME_JOIN(comp, INDIRECT)) | \
379                                   PASSMASK(PASS_NAME_JOIN(comp, COLOR)))
380
381 typedef enum PassType {
382         PASS_NONE = 0,
383
384         /* Main passes */
385         PASS_COMBINED = 1,
386         PASS_DEPTH,
387         PASS_NORMAL,
388         PASS_UV,
389         PASS_OBJECT_ID,
390         PASS_MATERIAL_ID,
391         PASS_MOTION,
392         PASS_MOTION_WEIGHT,
393 #ifdef __KERNEL_DEBUG__
394         PASS_BVH_TRAVERSED_NODES,
395         PASS_BVH_TRAVERSED_INSTANCES,
396         PASS_BVH_INTERSECTIONS,
397         PASS_RAY_BOUNCES,
398 #endif
399         PASS_RENDER_TIME,
400         PASS_CATEGORY_MAIN_END = 31,
401
402         PASS_MIST = 32,
403         PASS_EMISSION,
404         PASS_BACKGROUND,
405         PASS_AO,
406         PASS_SHADOW,
407         PASS_LIGHT, /* no real pass, used to force use_light_pass */
408         PASS_DIFFUSE_DIRECT,
409         PASS_DIFFUSE_INDIRECT,
410         PASS_DIFFUSE_COLOR,
411         PASS_GLOSSY_DIRECT,
412         PASS_GLOSSY_INDIRECT,
413         PASS_GLOSSY_COLOR,
414         PASS_TRANSMISSION_DIRECT,
415         PASS_TRANSMISSION_INDIRECT,
416         PASS_TRANSMISSION_COLOR,
417         PASS_SUBSURFACE_DIRECT,
418         PASS_SUBSURFACE_INDIRECT,
419         PASS_SUBSURFACE_COLOR,
420         PASS_VOLUME_DIRECT,
421         PASS_VOLUME_INDIRECT,
422         /* No Scatter color since it's tricky to define what it would even mean. */
423         PASS_CATEGORY_LIGHT_END = 63,
424 } PassType;
425
426 #define PASS_ANY (~0)
427
428 typedef enum DenoisingPassOffsets {
429         DENOISING_PASS_NORMAL             = 0,
430         DENOISING_PASS_NORMAL_VAR         = 3,
431         DENOISING_PASS_ALBEDO             = 6,
432         DENOISING_PASS_ALBEDO_VAR         = 9,
433         DENOISING_PASS_DEPTH              = 12,
434         DENOISING_PASS_DEPTH_VAR          = 13,
435         DENOISING_PASS_SHADOW_A           = 14,
436         DENOISING_PASS_SHADOW_B           = 17,
437         DENOISING_PASS_COLOR              = 20,
438         DENOISING_PASS_COLOR_VAR          = 23,
439
440         DENOISING_PASS_SIZE_BASE          = 26,
441         DENOISING_PASS_SIZE_CLEAN         = 3,
442 } DenoisingPassOffsets;
443
444 typedef enum eBakePassFilter {
445         BAKE_FILTER_NONE = 0,
446         BAKE_FILTER_DIRECT = (1 << 0),
447         BAKE_FILTER_INDIRECT = (1 << 1),
448         BAKE_FILTER_COLOR = (1 << 2),
449         BAKE_FILTER_DIFFUSE = (1 << 3),
450         BAKE_FILTER_GLOSSY = (1 << 4),
451         BAKE_FILTER_TRANSMISSION = (1 << 5),
452         BAKE_FILTER_SUBSURFACE = (1 << 6),
453         BAKE_FILTER_EMISSION = (1 << 7),
454         BAKE_FILTER_AO = (1 << 8),
455 } eBakePassFilter;
456
457 typedef enum BakePassFilterCombos {
458         BAKE_FILTER_COMBINED = (
459             BAKE_FILTER_DIRECT |
460             BAKE_FILTER_INDIRECT |
461             BAKE_FILTER_DIFFUSE |
462             BAKE_FILTER_GLOSSY |
463             BAKE_FILTER_TRANSMISSION |
464             BAKE_FILTER_SUBSURFACE |
465             BAKE_FILTER_EMISSION |
466             BAKE_FILTER_AO),
467         BAKE_FILTER_DIFFUSE_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_DIFFUSE),
468         BAKE_FILTER_GLOSSY_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_GLOSSY),
469         BAKE_FILTER_TRANSMISSION_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_TRANSMISSION),
470         BAKE_FILTER_SUBSURFACE_DIRECT = (BAKE_FILTER_DIRECT | BAKE_FILTER_SUBSURFACE),
471         BAKE_FILTER_DIFFUSE_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_DIFFUSE),
472         BAKE_FILTER_GLOSSY_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_GLOSSY),
473         BAKE_FILTER_TRANSMISSION_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_TRANSMISSION),
474         BAKE_FILTER_SUBSURFACE_INDIRECT = (BAKE_FILTER_INDIRECT | BAKE_FILTER_SUBSURFACE),
475 } BakePassFilterCombos;
476
477 typedef enum DenoiseFlag {
478         DENOISING_CLEAN_DIFFUSE_DIR      = (1 << 0),
479         DENOISING_CLEAN_DIFFUSE_IND      = (1 << 1),
480         DENOISING_CLEAN_GLOSSY_DIR       = (1 << 2),
481         DENOISING_CLEAN_GLOSSY_IND       = (1 << 3),
482         DENOISING_CLEAN_TRANSMISSION_DIR = (1 << 4),
483         DENOISING_CLEAN_TRANSMISSION_IND = (1 << 5),
484         DENOISING_CLEAN_SUBSURFACE_DIR   = (1 << 6),
485         DENOISING_CLEAN_SUBSURFACE_IND   = (1 << 7),
486         DENOISING_CLEAN_ALL_PASSES       = (1 << 8)-1,
487 } DenoiseFlag;
488
489 #ifdef __KERNEL_DEBUG__
490 /* NOTE: This is a runtime-only struct, alignment is not
491  * really important here.
492  */
493 typedef struct DebugData {
494         int num_bvh_traversed_nodes;
495         int num_bvh_traversed_instances;
496         int num_bvh_intersections;
497         int num_ray_bounces;
498 } DebugData;
499 #endif
500
501 typedef ccl_addr_space struct PathRadianceState {
502 #ifdef __PASSES__
503         float3 diffuse;
504         float3 glossy;
505         float3 transmission;
506         float3 subsurface;
507         float3 scatter;
508
509         float3 direct;
510 #endif
511 } PathRadianceState;
512
513 typedef ccl_addr_space struct PathRadiance {
514 #ifdef __PASSES__
515         int use_light_pass;
516 #endif
517
518         float transparent;
519         float3 emission;
520 #ifdef __PASSES__
521         float3 background;
522         float3 ao;
523
524         float3 indirect;
525         float3 direct_emission;
526
527         float3 color_diffuse;
528         float3 color_glossy;
529         float3 color_transmission;
530         float3 color_subsurface;
531
532         float3 direct_diffuse;
533         float3 direct_glossy;
534         float3 direct_transmission;
535         float3 direct_subsurface;
536         float3 direct_scatter;
537
538         float3 indirect_diffuse;
539         float3 indirect_glossy;
540         float3 indirect_transmission;
541         float3 indirect_subsurface;
542         float3 indirect_scatter;
543
544         float4 shadow;
545         float mist;
546 #endif
547
548         struct PathRadianceState state;
549
550 #ifdef __SHADOW_TRICKS__
551         /* Total light reachable across the path, ignoring shadow blocked queries. */
552         float3 path_total;
553         /* Total light reachable across the path with shadow blocked queries
554          * applied here.
555          *
556          * Dividing this figure by path_total will give estimate of shadow pass.
557          */
558         float3 path_total_shaded;
559
560         /* Color of the background on which shadow is alpha-overed. */
561         float3 shadow_background_color;
562
563         /* Path radiance sum and throughput at the moment when ray hits shadow
564          * catcher object.
565          */
566         float shadow_throughput;
567
568         /* Accumulated transparency along the path after shadow catcher bounce. */
569         float shadow_transparency;
570
571         /* Indicate if any shadow catcher data is set. */
572         int has_shadow_catcher;
573 #endif
574
575 #ifdef __DENOISING_FEATURES__
576         float3 denoising_normal;
577         float3 denoising_albedo;
578         float denoising_depth;
579 #endif  /* __DENOISING_FEATURES__ */
580
581 #ifdef __KERNEL_DEBUG__
582         DebugData debug_data;
583 #endif /* __KERNEL_DEBUG__ */
584 } PathRadiance;
585
586 typedef struct BsdfEval {
587 #ifdef __PASSES__
588         int use_light_pass;
589 #endif
590
591         float3 diffuse;
592 #ifdef __PASSES__
593         float3 glossy;
594         float3 transmission;
595         float3 transparent;
596         float3 subsurface;
597         float3 scatter;
598 #endif
599 #ifdef __SHADOW_TRICKS__
600         float3 sum_no_mis;
601 #endif
602 } BsdfEval;
603
604 /* Shader Flag */
605
606 typedef enum ShaderFlag {
607         SHADER_SMOOTH_NORMAL = (1 << 31),
608         SHADER_CAST_SHADOW = (1 << 30),
609         SHADER_AREA_LIGHT = (1 << 29),
610         SHADER_USE_MIS = (1 << 28),
611         SHADER_EXCLUDE_DIFFUSE = (1 << 27),
612         SHADER_EXCLUDE_GLOSSY = (1 << 26),
613         SHADER_EXCLUDE_TRANSMIT = (1 << 25),
614         SHADER_EXCLUDE_CAMERA = (1 << 24),
615         SHADER_EXCLUDE_SCATTER = (1 << 23),
616         SHADER_EXCLUDE_ANY = (SHADER_EXCLUDE_DIFFUSE|SHADER_EXCLUDE_GLOSSY|SHADER_EXCLUDE_TRANSMIT|SHADER_EXCLUDE_CAMERA|SHADER_EXCLUDE_SCATTER),
617
618         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT|SHADER_USE_MIS|SHADER_EXCLUDE_ANY)
619 } ShaderFlag;
620
621 /* Light Type */
622
623 typedef enum LightType {
624         LIGHT_POINT,
625         LIGHT_DISTANT,
626         LIGHT_BACKGROUND,
627         LIGHT_AREA,
628         LIGHT_SPOT,
629         LIGHT_TRIANGLE
630 } LightType;
631
632 /* Camera Type */
633
634 enum CameraType {
635         CAMERA_PERSPECTIVE,
636         CAMERA_ORTHOGRAPHIC,
637         CAMERA_PANORAMA
638 };
639
640 /* Panorama Type */
641
642 enum PanoramaType {
643         PANORAMA_EQUIRECTANGULAR = 0,
644         PANORAMA_FISHEYE_EQUIDISTANT = 1,
645         PANORAMA_FISHEYE_EQUISOLID = 2,
646         PANORAMA_MIRRORBALL = 3,
647
648         PANORAMA_NUM_TYPES,
649 };
650
651 /* Differential */
652
653 typedef struct differential3 {
654         float3 dx;
655         float3 dy;
656 } differential3;
657
658 typedef struct differential {
659         float dx;
660         float dy;
661 } differential;
662
663 /* Ray */
664
665 typedef struct Ray {
666 /* TODO(sergey): This is only needed because current AMD
667  * compiler has hard time building the kernel with this
668  * reshuffle. And at the same time reshuffle will cause
669  * less optimal CPU code in certain places.
670  *
671  * We'll get rid of this nasty exception once AMD compiler
672  * is fixed.
673  */
674 #ifndef __KERNEL_OPENCL_AMD__
675         float3 P;               /* origin */
676         float3 D;               /* direction */
677
678         float t;                /* length of the ray */
679         float time;             /* time (for motion blur) */
680 #else
681         float t;                /* length of the ray */
682         float time;             /* time (for motion blur) */
683         float3 P;               /* origin */
684         float3 D;               /* direction */
685 #endif
686
687 #ifdef __RAY_DIFFERENTIALS__
688         differential3 dP;
689         differential3 dD;
690 #endif
691 } Ray;
692
693 /* Intersection */
694
695 typedef struct Intersection {
696         float t, u, v;
697         int prim;
698         int object;
699         int type;
700
701 #ifdef __KERNEL_DEBUG__
702         int num_traversed_nodes;
703         int num_traversed_instances;
704         int num_intersections;
705 #endif
706 } Intersection;
707
708 /* Primitives */
709
710 typedef enum PrimitiveType {
711         PRIMITIVE_NONE            = 0,
712         PRIMITIVE_TRIANGLE        = (1 << 0),
713         PRIMITIVE_MOTION_TRIANGLE = (1 << 1),
714         PRIMITIVE_CURVE           = (1 << 2),
715         PRIMITIVE_MOTION_CURVE    = (1 << 3),
716         /* Lamp primitive is not included below on purpose,
717          * since it is no real traceable primitive.
718          */
719         PRIMITIVE_LAMP            = (1 << 4),
720
721         PRIMITIVE_ALL_TRIANGLE = (PRIMITIVE_TRIANGLE|PRIMITIVE_MOTION_TRIANGLE),
722         PRIMITIVE_ALL_CURVE = (PRIMITIVE_CURVE|PRIMITIVE_MOTION_CURVE),
723         PRIMITIVE_ALL_MOTION = (PRIMITIVE_MOTION_TRIANGLE|PRIMITIVE_MOTION_CURVE),
724         PRIMITIVE_ALL = (PRIMITIVE_ALL_TRIANGLE|PRIMITIVE_ALL_CURVE),
725
726         /* Total number of different traceable primitives.
727          * NOTE: This is an actual value, not a bitflag.
728          */
729         PRIMITIVE_NUM_TOTAL = 4,
730 } PrimitiveType;
731
732 #define PRIMITIVE_PACK_SEGMENT(type, segment) ((segment << PRIMITIVE_NUM_TOTAL) | (type))
733 #define PRIMITIVE_UNPACK_SEGMENT(type) (type >> PRIMITIVE_NUM_TOTAL)
734
735 /* Attributes */
736
737 typedef enum AttributePrimitive {
738         ATTR_PRIM_TRIANGLE = 0,
739         ATTR_PRIM_CURVE,
740         ATTR_PRIM_SUBD,
741
742         ATTR_PRIM_TYPES
743 } AttributePrimitive;
744
745 typedef enum AttributeElement {
746         ATTR_ELEMENT_NONE,
747         ATTR_ELEMENT_OBJECT,
748         ATTR_ELEMENT_MESH,
749         ATTR_ELEMENT_FACE,
750         ATTR_ELEMENT_VERTEX,
751         ATTR_ELEMENT_VERTEX_MOTION,
752         ATTR_ELEMENT_CORNER,
753         ATTR_ELEMENT_CORNER_BYTE,
754         ATTR_ELEMENT_CURVE,
755         ATTR_ELEMENT_CURVE_KEY,
756         ATTR_ELEMENT_CURVE_KEY_MOTION,
757         ATTR_ELEMENT_VOXEL
758 } AttributeElement;
759
760 typedef enum AttributeStandard {
761         ATTR_STD_NONE = 0,
762         ATTR_STD_VERTEX_NORMAL,
763         ATTR_STD_FACE_NORMAL,
764         ATTR_STD_UV,
765         ATTR_STD_UV_TANGENT,
766         ATTR_STD_UV_TANGENT_SIGN,
767         ATTR_STD_GENERATED,
768         ATTR_STD_GENERATED_TRANSFORM,
769         ATTR_STD_POSITION_UNDEFORMED,
770         ATTR_STD_POSITION_UNDISPLACED,
771         ATTR_STD_MOTION_VERTEX_POSITION,
772         ATTR_STD_MOTION_VERTEX_NORMAL,
773         ATTR_STD_PARTICLE,
774         ATTR_STD_CURVE_INTERCEPT,
775         ATTR_STD_PTEX_FACE_ID,
776         ATTR_STD_PTEX_UV,
777         ATTR_STD_VOLUME_DENSITY,
778         ATTR_STD_VOLUME_COLOR,
779         ATTR_STD_VOLUME_FLAME,
780         ATTR_STD_VOLUME_HEAT,
781         ATTR_STD_VOLUME_VELOCITY,
782         ATTR_STD_POINTINESS,
783         ATTR_STD_NUM,
784
785         ATTR_STD_NOT_FOUND = ~0
786 } AttributeStandard;
787
788 typedef enum AttributeFlag {
789         ATTR_FINAL_SIZE = (1 << 0),
790         ATTR_SUBDIVIDED = (1 << 1),
791 } AttributeFlag;
792
793 typedef struct AttributeDescriptor {
794         AttributeElement element;
795         NodeAttributeType type;
796         uint flags; /* see enum AttributeFlag */
797         int offset;
798 } AttributeDescriptor;
799
800 /* Closure data */
801
802 #ifdef __MULTI_CLOSURE__
803 #  ifdef __SPLIT_KERNEL__
804 #    define MAX_CLOSURE 1
805 #  else
806 #    ifndef __MAX_CLOSURE__
807 #       define MAX_CLOSURE 64
808 #    else
809 #      define MAX_CLOSURE __MAX_CLOSURE__
810 #    endif
811 #  endif
812 #else
813 #  define MAX_CLOSURE 1
814 #endif
815
816 /* This struct is the base class for all closures. The common members are
817  * duplicated in all derived classes since we don't have C++ in the kernel
818  * yet, and because it lets us lay out the members to minimize padding. The
819  * weight member is located at the beginning of the struct for this reason.
820  *
821  * ShaderClosure has a fixed size, and any extra space must be allocated
822  * with closure_alloc_extra().
823  *
824  * We pad the struct to 80 bytes and ensure it is aligned to 16 bytes, which
825  * we assume to be the maximum required alignment for any struct. */
826
827 #define SHADER_CLOSURE_BASE \
828         float3 weight; \
829         ClosureType type; \
830         float sample_weight; \
831         float3 N
832
833 typedef ccl_addr_space struct ccl_align(16) ShaderClosure {
834         SHADER_CLOSURE_BASE;
835
836         float data[10]; /* pad to 80 bytes */
837 } ShaderClosure;
838
839 /* Shader Data
840  *
841  * Main shader state at a point on the surface or in a volume. All coordinates
842  * are in world space.
843  */
844
845 enum ShaderDataFlag {
846         /* Runtime flags. */
847
848         /* Set when ray hits backside of surface. */
849         SD_BACKFACING      = (1 << 0),
850         /* Shader has non-zero emission. */
851         SD_EMISSION        = (1 << 1),
852         /* Shader has BSDF closure. */
853         SD_BSDF            = (1 << 2),
854         /* Shader has non-singular BSDF closure. */
855         SD_BSDF_HAS_EVAL   = (1 << 3),
856         /* Shader has BSSRDF closure. */
857         SD_BSSRDF          = (1 << 4),
858         /* Shader has holdout closure. */
859         SD_HOLDOUT         = (1 << 5),
860         /* Shader has non-zero volume extinction. */
861         SD_EXTINCTION      = (1 << 6),
862         /* Shader has have volume phase (scatter) closure. */
863         SD_SCATTER         = (1 << 7),
864         /* Shader has AO closure. */
865         SD_AO              = (1 << 8),
866         /* Shader has transparent closure. */
867         SD_TRANSPARENT     = (1 << 9),
868         /* BSDF requires LCG for evaluation. */
869         SD_BSDF_NEEDS_LCG  = (1 << 10),
870
871         SD_CLOSURE_FLAGS = (SD_EMISSION |
872                             SD_BSDF |
873                             SD_BSDF_HAS_EVAL |
874                             SD_BSSRDF |
875                             SD_HOLDOUT |
876                             SD_EXTINCTION |
877                             SD_SCATTER |
878                             SD_AO |
879                             SD_BSDF_NEEDS_LCG),
880
881         /* Shader flags. */
882
883         /* direct light sample */
884         SD_USE_MIS                = (1 << 16),
885         /* Has transparent shadow. */
886         SD_HAS_TRANSPARENT_SHADOW = (1 << 17),
887         /* Has volume shader. */
888         SD_HAS_VOLUME             = (1 << 18),
889         /* Has only volume shader, no surface. */
890         SD_HAS_ONLY_VOLUME        = (1 << 19),
891         /* Has heterogeneous volume. */
892         SD_HETEROGENEOUS_VOLUME   = (1 << 20),
893         /* BSSRDF normal uses bump. */
894         SD_HAS_BSSRDF_BUMP        = (1 << 21),
895         /* Use equiangular volume sampling */
896         SD_VOLUME_EQUIANGULAR     = (1 << 22),
897         /* Use multiple importance volume sampling. */
898         SD_VOLUME_MIS             = (1 << 23),
899         /* Use cubic interpolation for voxels. */
900         SD_VOLUME_CUBIC           = (1 << 24),
901         /* Has data connected to the displacement input or uses bump map. */
902         SD_HAS_BUMP               = (1 << 25),
903         /* Has true displacement. */
904         SD_HAS_DISPLACEMENT       = (1 << 26),
905         /* Has constant emission (value stored in __shader_flag) */
906         SD_HAS_CONSTANT_EMISSION  = (1 << 27),
907
908         SD_SHADER_FLAGS = (SD_USE_MIS |
909                            SD_HAS_TRANSPARENT_SHADOW |
910                            SD_HAS_VOLUME |
911                            SD_HAS_ONLY_VOLUME |
912                            SD_HETEROGENEOUS_VOLUME|
913                            SD_HAS_BSSRDF_BUMP |
914                            SD_VOLUME_EQUIANGULAR |
915                            SD_VOLUME_MIS |
916                            SD_VOLUME_CUBIC |
917                            SD_HAS_BUMP |
918                            SD_HAS_DISPLACEMENT |
919                            SD_HAS_CONSTANT_EMISSION)
920 };
921
922         /* Object flags. */
923 enum ShaderDataObjectFlag {
924         /* Holdout for camera rays. */
925         SD_OBJECT_HOLDOUT_MASK           = (1 << 0),
926         /* Has object motion blur. */
927         SD_OBJECT_MOTION                 = (1 << 1),
928         /* Vertices have transform applied. */
929         SD_OBJECT_TRANSFORM_APPLIED      = (1 << 2),
930         /* Vertices have negative scale applied. */
931         SD_OBJECT_NEGATIVE_SCALE_APPLIED = (1 << 3),
932         /* Object has a volume shader. */
933         SD_OBJECT_HAS_VOLUME             = (1 << 4),
934         /* Object intersects AABB of an object with volume shader. */
935         SD_OBJECT_INTERSECTS_VOLUME      = (1 << 5),
936         /* Has position for motion vertices. */
937         SD_OBJECT_HAS_VERTEX_MOTION      = (1 << 6),
938         /* object is used to catch shadows */
939         SD_OBJECT_SHADOW_CATCHER         = (1 << 7),
940
941         SD_OBJECT_FLAGS = (SD_OBJECT_HOLDOUT_MASK |
942                            SD_OBJECT_MOTION |
943                            SD_OBJECT_TRANSFORM_APPLIED |
944                            SD_OBJECT_NEGATIVE_SCALE_APPLIED |
945                            SD_OBJECT_HAS_VOLUME |
946                            SD_OBJECT_INTERSECTS_VOLUME |
947                            SD_OBJECT_SHADOW_CATCHER)
948 };
949
950 typedef ccl_addr_space struct ShaderData {
951         /* position */
952         float3 P;
953         /* smooth normal for shading */
954         float3 N;
955         /* true geometric normal */
956         float3 Ng;
957         /* view/incoming direction */
958         float3 I;
959         /* shader id */
960         int shader;
961         /* booleans describing shader, see ShaderDataFlag */
962         int flag;
963         /* booleans describing object of the shader, see ShaderDataObjectFlag */
964         int object_flag;
965
966         /* primitive id if there is one, ~0 otherwise */
967         int prim;
968
969         /* combined type and curve segment for hair */
970         int type;
971
972         /* parametric coordinates
973          * - barycentric weights for triangles */
974         float u;
975         float v;
976         /* object id if there is one, ~0 otherwise */
977         int object;
978         /* lamp id if there is one, ~0 otherwise */
979         int lamp;
980
981         /* motion blur sample time */
982         float time;
983
984         /* length of the ray being shaded */
985         float ray_length;
986
987 #ifdef __RAY_DIFFERENTIALS__
988         /* differential of P. these are orthogonal to Ng, not N */
989         differential3 dP;
990         /* differential of I */
991         differential3 dI;
992         /* differential of u, v */
993         differential du;
994         differential dv;
995 #endif
996 #ifdef __DPDU__
997         /* differential of P w.r.t. parametric coordinates. note that dPdu is
998          * not readily suitable as a tangent for shading on triangles. */
999         float3 dPdu;
1000         float3 dPdv;
1001 #endif
1002
1003 #ifdef __OBJECT_MOTION__
1004         /* object <-> world space transformations, cached to avoid
1005          * re-interpolating them constantly for shading */
1006         Transform ob_tfm;
1007         Transform ob_itfm;
1008 #endif
1009
1010         /* ray start position, only set for backgrounds */
1011         float3 ray_P;
1012         differential3 ray_dP;
1013
1014 #ifdef __OSL__
1015         struct KernelGlobals *osl_globals;
1016         struct PathState *osl_path_state;
1017 #endif
1018
1019         /* LCG state for closures that require additional random numbers. */
1020         uint lcg_state;
1021
1022         /* Closure data, we store a fixed array of closures */
1023         int num_closure;
1024         int num_closure_left;
1025         float randb_closure;
1026         float3 svm_closure_weight;
1027
1028         /* Closure weights summed directly, so we can evaluate
1029          * emission and shadow transparency with MAX_CLOSURE 0. */
1030         float3 closure_emission_background;
1031         float3 closure_transparent_extinction;
1032
1033         /* At the end so we can adjust size in ShaderDataTinyStorage. */
1034         struct ShaderClosure closure[MAX_CLOSURE];
1035 } ShaderData;
1036
1037 typedef ccl_addr_space struct ShaderDataTinyStorage {
1038         char pad[sizeof(ShaderData) - sizeof(ShaderClosure) * MAX_CLOSURE];
1039 } ShaderDataTinyStorage;
1040 #define AS_SHADER_DATA(shader_data_tiny_storage) ((ShaderData*)shader_data_tiny_storage)
1041
1042 /* Path State */
1043
1044 #ifdef __VOLUME__
1045 typedef struct VolumeStack {
1046         int object;
1047         int shader;
1048 } VolumeStack;
1049 #endif
1050
1051 typedef struct PathState {
1052         /* see enum PathRayFlag */
1053         int flag;
1054
1055         /* random number generator state */
1056         uint rng_hash;          /* per pixel hash */
1057         int rng_offset;         /* dimension offset */
1058         int sample;             /* path sample number */
1059         int num_samples;        /* total number of times this path will be sampled */
1060         float branch_factor;    /* number of branches in indirect paths */
1061
1062         /* bounce counting */
1063         int bounce;
1064         int diffuse_bounce;
1065         int glossy_bounce;
1066         int transmission_bounce;
1067         int transparent_bounce;
1068
1069 #ifdef __DENOISING_FEATURES__
1070         float denoising_feature_weight;
1071 #endif  /* __DENOISING_FEATURES__ */
1072
1073         /* multiple importance sampling */
1074         float min_ray_pdf; /* smallest bounce pdf over entire path up to now */
1075         float ray_pdf;     /* last bounce pdf */
1076 #ifdef __LAMP_MIS__
1077         float ray_t;       /* accumulated distance through transparent surfaces */
1078 #endif
1079
1080         /* volume rendering */
1081 #ifdef __VOLUME__
1082         int volume_bounce;
1083         uint rng_congruential;
1084         VolumeStack volume_stack[VOLUME_STACK_SIZE];
1085 #endif
1086 } PathState;
1087
1088 /* Struct to gather multiple nearby intersections. */
1089 typedef struct LocalIntersection {
1090         Ray ray;
1091         float3 weight[LOCAL_MAX_HITS];
1092
1093         int num_hits;
1094         struct Intersection hits[LOCAL_MAX_HITS];
1095         float3 Ng[LOCAL_MAX_HITS];
1096 } LocalIntersection;
1097
1098 /* Subsurface */
1099
1100 /* Struct to gather SSS indirect rays and delay tracing them. */
1101 typedef struct SubsurfaceIndirectRays {
1102         PathState state[BSSRDF_MAX_HITS];
1103
1104         int num_rays;
1105
1106         struct Ray rays[BSSRDF_MAX_HITS];
1107         float3 throughputs[BSSRDF_MAX_HITS];
1108         struct PathRadianceState L_state[BSSRDF_MAX_HITS];
1109 } SubsurfaceIndirectRays;
1110 static_assert(BSSRDF_MAX_HITS <= LOCAL_MAX_HITS, "BSSRDF hits too high.");
1111
1112 /* Constant Kernel Data
1113  *
1114  * These structs are passed from CPU to various devices, and the struct layout
1115  * must match exactly. Structs are padded to ensure 16 byte alignment, and we
1116  * do not use float3 because its size may not be the same on all devices. */
1117
1118 typedef struct KernelCamera {
1119         /* type */
1120         int type;
1121
1122         /* panorama */
1123         int panorama_type;
1124         float fisheye_fov;
1125         float fisheye_lens;
1126         float4 equirectangular_range;
1127
1128         /* stereo */
1129         float interocular_offset;
1130         float convergence_distance;
1131         float pole_merge_angle_from;
1132         float pole_merge_angle_to;
1133
1134         /* matrices */
1135         Transform cameratoworld;
1136         Transform rastertocamera;
1137
1138         /* differentials */
1139         float4 dx;
1140         float4 dy;
1141
1142         /* depth of field */
1143         float aperturesize;
1144         float blades;
1145         float bladesrotation;
1146         float focaldistance;
1147
1148         /* motion blur */
1149         float shuttertime;
1150         int have_motion, have_perspective_motion;
1151
1152         /* clipping */
1153         float nearclip;
1154         float cliplength;
1155
1156         /* sensor size */
1157         float sensorwidth;
1158         float sensorheight;
1159
1160         /* render size */
1161         float width, height;
1162         int resolution;
1163
1164         /* anamorphic lens bokeh */
1165         float inv_aperture_ratio;
1166
1167         int is_inside_volume;
1168
1169         /* more matrices */
1170         Transform screentoworld;
1171         Transform rastertoworld;
1172         /* work around cuda sm 2.0 crash, this seems to
1173          * cross some limit in combination with motion 
1174          * Transform ndctoworld; */
1175         Transform worldtoscreen;
1176         Transform worldtoraster;
1177         Transform worldtondc;
1178         Transform worldtocamera;
1179
1180         MotionTransform motion;
1181
1182         /* Denotes changes in the projective matrix, namely in rastertocamera.
1183          * Used for camera zoom motion blur,
1184          */
1185         PerspectiveMotionTransform perspective_motion;
1186
1187         int shutter_table_offset;
1188
1189         /* Rolling shutter */
1190         int rolling_shutter_type;
1191         float rolling_shutter_duration;
1192
1193         int pad;
1194 } KernelCamera;
1195 static_assert_align(KernelCamera, 16);
1196
1197 typedef struct KernelFilm {
1198         float exposure;
1199         int pass_flag;
1200         int light_pass_flag;
1201         int pass_stride;
1202         int use_light_pass;
1203
1204         int pass_combined;
1205         int pass_depth;
1206         int pass_normal;
1207         int pass_motion;
1208
1209         int pass_motion_weight;
1210         int pass_uv;
1211         int pass_object_id;
1212         int pass_material_id;
1213
1214         int pass_diffuse_color;
1215         int pass_glossy_color;
1216         int pass_transmission_color;
1217         int pass_subsurface_color;
1218         
1219         int pass_diffuse_indirect;
1220         int pass_glossy_indirect;
1221         int pass_transmission_indirect;
1222         int pass_subsurface_indirect;
1223         int pass_volume_indirect;
1224         
1225         int pass_diffuse_direct;
1226         int pass_glossy_direct;
1227         int pass_transmission_direct;
1228         int pass_subsurface_direct;
1229         int pass_volume_direct;
1230         
1231         int pass_emission;
1232         int pass_background;
1233         int pass_ao;
1234         float pass_alpha_threshold;
1235
1236         int pass_shadow;
1237         float pass_shadow_scale;
1238         int filter_table_offset;
1239
1240         int pass_mist;
1241         float mist_start;
1242         float mist_inv_depth;
1243         float mist_falloff;
1244
1245         int pass_denoising_data;
1246         int pass_denoising_clean;
1247         int denoising_flags;
1248
1249         int pad1, pad2, pad3;
1250
1251 #ifdef __KERNEL_DEBUG__
1252         int pass_bvh_traversed_nodes;
1253         int pass_bvh_traversed_instances;
1254         int pass_bvh_intersections;
1255         int pass_ray_bounces;
1256 #endif
1257 } KernelFilm;
1258 static_assert_align(KernelFilm, 16);
1259
1260 typedef struct KernelBackground {
1261         /* only shader index */
1262         int surface_shader;
1263         int volume_shader;
1264         int transparent;
1265         float transparent_roughness_squared_threshold;
1266
1267         /* ambient occlusion */
1268         float ao_factor;
1269         float ao_distance;
1270         float ao_bounces_factor;
1271         float ao_pad;
1272 } KernelBackground;
1273 static_assert_align(KernelBackground, 16);
1274
1275 typedef struct KernelIntegrator {
1276         /* emission */
1277         int use_direct_light;
1278         int use_ambient_occlusion;
1279         int num_distribution;
1280         int num_all_lights;
1281         float pdf_triangles;
1282         float pdf_lights;
1283         int pdf_background_res;
1284         float light_inv_rr_threshold;
1285
1286         /* light portals */
1287         float portal_pdf;
1288         int num_portals;
1289         int portal_offset;
1290
1291         /* bounces */
1292         int max_bounce;
1293
1294         int max_diffuse_bounce;
1295         int max_glossy_bounce;
1296         int max_transmission_bounce;
1297         int max_volume_bounce;
1298
1299         int ao_bounces;
1300
1301         /* transparent */
1302         int transparent_max_bounce;
1303         int transparent_shadows;
1304
1305         /* caustics */
1306         int caustics_reflective;
1307         int caustics_refractive;
1308         float filter_glossy;
1309
1310         /* seed */
1311         int seed;
1312
1313         /* clamp */
1314         float sample_clamp_direct;
1315         float sample_clamp_indirect;
1316
1317         /* branched path */
1318         int branched;
1319         int volume_decoupled;
1320         int diffuse_samples;
1321         int glossy_samples;
1322         int transmission_samples;
1323         int ao_samples;
1324         int mesh_light_samples;
1325         int subsurface_samples;
1326         int sample_all_lights_direct;
1327         int sample_all_lights_indirect;
1328
1329         /* mis */
1330         int use_lamp_mis;
1331
1332         /* sampler */
1333         int sampling_pattern;
1334         int aa_samples;
1335
1336         /* volume render */
1337         int use_volumes;
1338         int volume_max_steps;
1339         float volume_step_size;
1340         int volume_samples;
1341
1342         int start_sample;
1343
1344         int max_closures;
1345 } KernelIntegrator;
1346 static_assert_align(KernelIntegrator, 16);
1347
1348 typedef enum KernelBVHLayout {
1349         BVH_LAYOUT_NONE = 0,
1350
1351         BVH_LAYOUT_BVH2 = (1 << 0),
1352         BVH_LAYOUT_BVH4 = (1 << 1),
1353
1354         BVH_LAYOUT_DEFAULT = BVH_LAYOUT_BVH4,
1355         BVH_LAYOUT_ALL = (unsigned int)(-1),
1356 } KernelBVHLayout;
1357
1358 typedef struct KernelBVH {
1359         /* root node */
1360         int root;
1361         int have_motion;
1362         int have_curves;
1363         int have_instancing;
1364         int bvh_layout;
1365         int use_bvh_steps;
1366         int pad1, pad2;
1367 } KernelBVH;
1368 static_assert_align(KernelBVH, 16);
1369
1370 typedef enum CurveFlag {
1371         /* runtime flags */
1372         CURVE_KN_BACKFACING = 1,                                /* backside of cylinder? */
1373         CURVE_KN_ENCLOSEFILTER = 2,                             /* don't consider strands surrounding start point? */
1374         CURVE_KN_INTERPOLATE = 4,                               /* render as a curve? */
1375         CURVE_KN_ACCURATE = 8,                                  /* use accurate intersections test? */
1376         CURVE_KN_INTERSECTCORRECTION = 16,              /* correct for width after determing closest midpoint? */
1377         CURVE_KN_TRUETANGENTGNORMAL = 32,               /* use tangent normal for geometry? */
1378         CURVE_KN_RIBBONS = 64,                                  /* use flat curve ribbons */
1379 } CurveFlag;
1380
1381 typedef struct KernelCurves {
1382         int curveflags;
1383         int subdivisions;
1384
1385         float minimum_width;
1386         float maximum_width;
1387 } KernelCurves;
1388 static_assert_align(KernelCurves, 16);
1389
1390 typedef struct KernelTables {
1391         int beckmann_offset;
1392         int pad1, pad2, pad3;
1393 } KernelTables;
1394 static_assert_align(KernelTables, 16);
1395
1396 typedef struct KernelData {
1397         KernelCamera cam;
1398         KernelFilm film;
1399         KernelBackground background;
1400         KernelIntegrator integrator;
1401         KernelBVH bvh;
1402         KernelCurves curve;
1403         KernelTables tables;
1404 } KernelData;
1405 static_assert_align(KernelData, 16);
1406
1407 /* Declarations required for split kernel */
1408
1409 /* Macro for queues */
1410 /* Value marking queue's empty slot */
1411 #define QUEUE_EMPTY_SLOT -1
1412
1413 /*
1414  * Queue 1 - Active rays
1415  * Queue 2 - Background queue
1416  * Queue 3 - Shadow ray cast kernel - AO
1417  * Queeu 4 - Shadow ray cast kernel - direct lighting
1418  */
1419
1420 /* Queue names */
1421 enum QueueNumber {
1422         /* All active rays and regenerated rays are enqueued here. */
1423         QUEUE_ACTIVE_AND_REGENERATED_RAYS = 0,
1424
1425         /* All
1426          * 1. Background-hit rays,
1427          * 2. Rays that has exited path-iteration but needs to update output buffer
1428          * 3. Rays to be regenerated
1429          * are enqueued here.
1430          */
1431         QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS,
1432
1433         /* All rays for which a shadow ray should be cast to determine radiance
1434          * contribution for AO are enqueued here.
1435          */
1436         QUEUE_SHADOW_RAY_CAST_AO_RAYS,
1437
1438         /* All rays for which a shadow ray should be cast to determine radiance
1439          * contributing for direct lighting are enqueued here.
1440          */
1441         QUEUE_SHADOW_RAY_CAST_DL_RAYS,
1442
1443         /* Rays sorted according to shader->id */
1444         QUEUE_SHADER_SORTED_RAYS,
1445
1446 #ifdef __BRANCHED_PATH__
1447         /* All rays moving to next iteration of the indirect loop for light */
1448         QUEUE_LIGHT_INDIRECT_ITER,
1449         /* Queue of all inactive rays. These are candidates for sharing work of indirect loops */
1450         QUEUE_INACTIVE_RAYS,
1451 #  ifdef __VOLUME__
1452         /* All rays moving to next iteration of the indirect loop for volumes */
1453         QUEUE_VOLUME_INDIRECT_ITER,
1454 #  endif
1455 #  ifdef __SUBSURFACE__
1456         /* All rays moving to next iteration of the indirect loop for subsurface */
1457         QUEUE_SUBSURFACE_INDIRECT_ITER,
1458 #  endif
1459 #endif  /* __BRANCHED_PATH__ */
1460
1461         NUM_QUEUES
1462 };
1463
1464 /* We use RAY_STATE_MASK to get ray_state */
1465 #define RAY_STATE_MASK 0x0F
1466 #define RAY_FLAG_MASK 0xF0
1467 enum RayState {
1468         RAY_INVALID = 0,
1469         /* Denotes ray is actively involved in path-iteration. */
1470         RAY_ACTIVE,
1471         /* Denotes ray has completed processing all samples and is inactive. */
1472         RAY_INACTIVE,
1473         /* Denoted ray has exited path-iteration and needs to update output buffer. */
1474         RAY_UPDATE_BUFFER,
1475         /* Donotes ray has hit background */
1476         RAY_HIT_BACKGROUND,
1477         /* Denotes ray has to be regenerated */
1478         RAY_TO_REGENERATE,
1479         /* Denotes ray has been regenerated */
1480         RAY_REGENERATED,
1481         /* Denotes ray is moving to next iteration of the branched indirect loop */
1482         RAY_LIGHT_INDIRECT_NEXT_ITER,
1483         RAY_VOLUME_INDIRECT_NEXT_ITER,
1484         RAY_SUBSURFACE_INDIRECT_NEXT_ITER,
1485
1486         /* Ray flags */
1487
1488         /* Flags to denote that the ray is currently evaluating the branched indirect loop */
1489         RAY_BRANCHED_LIGHT_INDIRECT = (1 << 4),
1490         RAY_BRANCHED_VOLUME_INDIRECT = (1 << 5),
1491         RAY_BRANCHED_SUBSURFACE_INDIRECT = (1 << 6),
1492         RAY_BRANCHED_INDIRECT = (RAY_BRANCHED_LIGHT_INDIRECT | RAY_BRANCHED_VOLUME_INDIRECT | RAY_BRANCHED_SUBSURFACE_INDIRECT),
1493
1494         /* Ray is evaluating an iteration of an indirect loop for another thread */
1495         RAY_BRANCHED_INDIRECT_SHARED = (1 << 7),
1496 };
1497
1498 #define ASSIGN_RAY_STATE(ray_state, ray_index, state) (ray_state[ray_index] = ((ray_state[ray_index] & RAY_FLAG_MASK) | state))
1499 #define IS_STATE(ray_state, ray_index, state) ((ray_index) != QUEUE_EMPTY_SLOT && ((ray_state)[(ray_index)] & RAY_STATE_MASK) == (state))
1500 #define ADD_RAY_FLAG(ray_state, ray_index, flag) (ray_state[ray_index] = (ray_state[ray_index] | flag))
1501 #define REMOVE_RAY_FLAG(ray_state, ray_index, flag) (ray_state[ray_index] = (ray_state[ray_index] & (~flag)))
1502 #define IS_FLAG(ray_state, ray_index, flag) (ray_state[ray_index] & flag)
1503
1504 /* Patches */
1505
1506 #define PATCH_MAX_CONTROL_VERTS 16
1507
1508 /* Patch map node flags */
1509
1510 #define PATCH_MAP_NODE_IS_SET (1 << 30)
1511 #define PATCH_MAP_NODE_IS_LEAF (1u << 31)
1512 #define PATCH_MAP_NODE_INDEX_MASK (~(PATCH_MAP_NODE_IS_SET | PATCH_MAP_NODE_IS_LEAF))
1513
1514 /* Work Tiles */
1515
1516 typedef struct WorkTile {
1517         uint x, y, w, h;
1518
1519         uint start_sample;
1520         uint num_samples;
1521
1522         uint offset;
1523         uint stride;
1524
1525         ccl_global float *buffer;
1526 } WorkTile;
1527
1528 CCL_NAMESPACE_END
1529
1530 #endif /*  __KERNEL_TYPES_H__ */
1531