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