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