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