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