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