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